Extends 面向对象的 继承。

　　继承的基本概念描述：

 

 继承中访问成员变量的特点：（重名的使用规则） 

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找。

父类：

public class Fu {

    int numFu = 10;

    int num = 100;

    public void methodFu() {
        // 使用的是本类当中的，不会向下找子类的
        System.out.println(num);
    }

}
　　　　　

 子类：

public class Zi extends Fu {

    int numZi = 20;

    int num = 200;

    public void methodZi() {
        // 因为本类当中有num，所以这里用的是本类的num
        System.out.println(num);
    }

}

。。。。

public class Demo01ExtendsField {

    public static void main(String[] args) {
        Fu fu = new Fu(); // 创建父类对象
        System.out.println(fu.numFu); // 只能使用父类的东西，没有任何子类内容
        System.out.println("===========");

        Zi zi = new Zi();

        System.out.println(zi.numFu); // 10
        System.out.println(zi.numZi); // 20
        System.out.println("===========");

        // 等号左边是谁，就优先用谁
        System.out.println(zi.num); // 优先子类，200
//        System.out.println(zi.abc); // 到处都没有，编译报错！
        System.out.println("===========");

        // 这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类当中定义的，
        zi.methodFu(); // 100
    }

}

===========================================================================

 

 

区分子类中重名的三种变量。

 

父类：

public class fu {
    int num = 10;

}

子类：

public class zi extends fu {
    int num = 20;


    public void method() {
　　　　　int num = 30;

        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);

    }


}

。。。

public class Demo01ExtendsField {
    public static void main(String[] args) {
        zi zi = new zi();
        zi.method();
    }
}

 

效果：

10

20

30 

 

 =========================================================================

继承中成员方法的访问特点；

在父子类的继承关系中，创建子类对象，访问成员方法的规则：

创建的对象是谁，就优先用谁，如果没有则向上找。（按照正常情况下 ，父类和子类都有相同的名称的成员方法，

那就优先选择子类的，后者再选择父类。）

 

注意事项；

无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会找向下找子类的。

 

=============================================================================

在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

 

================================================================================

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。 

（但 大多数情况下  只要保证父子类的【方法名称】和【参数列表】相同就可以了）

================================================================================

继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的【父类构造】，后执行的子类构造。

2. 子类构造可以通过super关键字来调用父类重载构造。

3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

 

父类：

public class Fu {

    public Fu() {
        System.out.println("父类无参构造");
    }

    public Fu(int num) {
        System.out.println("父类有参构造！");
    }

}

 子类：

public class Zi extends Fu {

    public Zi() {
        super(); // 在调用父类无参构造方法
//        super(20); // 在调用父类重载的构造方法
        System.out.println("子类构造方法！");
    }

    public void method() {
//        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }

}

。。。。

public class Demo01Constructor {

    public static void main(String[] args) {
        Zi zi = new Zi();
    }

}

 

==========================================================

super关键字的用法有三种：
1. 在子类的成员方法中，访问父类的成员变量。 #1
2. 在子类的成员方法中，访问父类的成员方法。 #2
3. 在子类的构造方法中，访问父类的构造方法。 #3

父类；

public class Fu {

    int num = 10;

    public void method() {
        System.out.println("父类方法");
    }

}

子类：

public class Zi extends Fu {

    int num = 20;

    public Zi() {
        super();   //        #3
    }

    public void methodZi() {
        System.out.println(super.num); // 父类中的num  // #1
    }

    public void method() {
        super.method(); // 访问父类中的method   // #2
        System.out.println("子类方法");
    }

}

 =======================================================

【this】关键字典型用法。

super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
在第三种用法当中要注意：
A. this(...)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。

 

父类：

public class Fu {

    int num = 30;

}

子类：

public class Zi extends Fu {

    int num = 20;

    public Zi() {
//        super(); // 这一行不再赠送
        this(123); // 本类的无参构造，调用本类的有参构造
//        this(1, 2); // 错误写法！
    }

    public Zi(int n) {
        this(1, 2);
    }

    public Zi(int n, int m) {
    }

    public void showNum() {
        int num = 10;
        System.out.println(num); // 局部变量
        System.out.println(this.num); // 本类中的成员变量
        System.out.println(super.num); // 父类中的成员变量
    }

    public void methodA() {
        System.out.println("AAA");
    }

    public void methodB() {
        this.methodA();
        System.out.println("BBB");
    }

}

super和this关键字图解，

 

  

 

java继承的三大特点；