JAVA继承_在继承关系中,子类就是一个父类

继承

继承的格式

在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

定义父类的格式：（一个普通的类定义）

public class 父类名称 {
    // ...
}
1
2
3

定义子类的格式：

public class 子类名称 extends 父类名称 {
    // ...
}
1
2
3

示例代码

父类

public class Fu {

    int numFu = 10;

    int num = 100;

    int age = 30;

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

子类

public class Zi extends Fu {

    int numZi = 20;

    int num = 200;

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

}
1
2
3
4
5
6
7
8
9
10
11
12

调用

public class Demo01ExtendsField {
    public static void main(String[] args) {
        Zi z = new Zi();
        System.out.println(z.age);  // 30

        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
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

继承访问成员变量

• 对于成员变量，字类可以访问父类中定义的成员变量

访问同名的成员变量

直接访问同名的成员变量

引用类型 a = new 实例的真正类型()
1

• 看实例的引用类型，子类实例打印子类的成员变量的值，父类实例打印父类成员变量的值

总结：等号左边是谁，就优先用谁，没有则向上找。

        Zi zi = new Zi();
        System.out.println(zi.num); // 200
        System.out.println(fu.num); // 父类引用, 100
1
2
3

间接访问同名的成员变量（在成员方法中访问）

看访问的方法是所在的类，该方法属于谁，就优先用谁，没有则向上找。

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

继承访问成员方法

方法的覆盖重写

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

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

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

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

• 重载（Overload）：方法的名称一样，参数列表【不一样】。

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

方法覆盖重写的注意事项

覆盖重写的方法的调用

A obj = new B();
obj.method();
1
2

• 具体调用的哪个方法，看obj的对象实例类型，即B的类型

this,super关键字

• 局部变量： 直接写成员变量名
• 本类的成员变量： this.成员变量名
• 父类的成员变量： super.成员变量名

子类

public class Zi extends Fu {
    int num = 20;
    public void method() {
        int num = 30;
        System.out.println(num); // 30，局部变量
        System.out.println(this.num); // 20，本类的成员变量
        System.out.println(super.num); // 10，父类的成员变量
    }
}
1
2
3
4
5
6
7
8
9

父类

public class Fu {
    int num = 10;
    public void getNum(){
        System.out.println(this.num); // 10 这里的this是定义在父类中的，然后它间接的访问本类的成员变量，所有值是this。
    }
}
1
2
3
4
5
6

main

public class Demo01ExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
        zi.getNum();
    }
}
1
2
3
4
5
6
7

继承中的构造方法

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

• 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
• 子类构造可以通过super关键字来调用父类重载构造。
• super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

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

注： super()构造方法必须是子类的构造方法的第一个语句，也只能存在于子类的构造方法中。

父类

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

    public Fu(int num) {
        System.out.println("父类有参构造！");
    }
}
1
2
3
4
5
6
7
8
9

子类

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

    public void method() {
//        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }
}
1
2
3
4
5
6
7
8
9
10
11

super关键字的用法

super关键字的用法有三种：

1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。

this关键字的用法

this关键字的用法也有三种

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。

在第三种用法当中要注意：
A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。

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) {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17