Java_笔记_继承_虚方法表_成员变量方法构造_thisSuper

一、继承的概念以及优势：

1.概念：
1）继承是面向对象三大特征（封装，继承，多态）之一，可让类与类之间产生子父的关系。
2）封装：对象代表什么，就封装对应的数据，并提供数据对应的行为。

2.继承的格式：
Java中提供一个关键字extends，让一个类与另一个类建立起继承关系。
public class Student extends Person{}
Student称为子类（派生类），Person称为父类（基类或超类）。

3.使用继承的优势：
1）减少代码冗余，提高代码的复用性，将多个子类中重复的代码抽取到父类中，子类可直接使用。
2）使子类更强大，子类可在父类基础上，增加其他的功能。

4.继承后子类的特点：
1）子类可以得到父类的属性和行为，子类可以使用。
2）子类可以在父类的基础上新增其他功能，子类更强大。

5.继承需要学习的点：自己设计；用别人的。
6.什么时候用继承优化代码：
当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种。

二、继承的特点

1.Java只支持单继承：
一个类只能继承一个直接父类。
2.不支持多继承：
子类不能同时继承多个父类。
3.但支持多层继承：
1）子类A继承父类B，父类B可以继承父类C。
2）对于A来说，B是直接父类，C是间接父类。
4.Java中每一个类都直接或者间接继承于Object类。
5.子类只能访问父类中非私有的成员。
6.继承的练习（自己设计一个继承体系）
现在有四种动物：布偶猫、狸花猫、哈士奇、泰迪。
暂时不考虑属性，只要考虑行为。
请按照继承的思想特点进行继承体系的设计。

四种动物分别有以下的行为：
布偶猫：吃饭、喝水、抓老鼠
狸花猫：吃饭、喝水、抓老鼠
哈士奇：吃饭、喝水、看家、拆家
泰迪：吃饭、喝水、看家、烫卷毛

1）画图法：
从下往上画；
下面：子类；
上面：父类；
需要把子类中的共性内容抽取到父类中。

2）核心：
共性内容抽取；子类是父类中的一种

3）书写代码：
从上往下写。

4）代码：

public class Animal {
    //权限修饰符
    //private：子类无法访问
    //私有只能在本类中访问
    //★★★子类只能访问父类中非私有的成员
    public void eat() {
        System.out.println("吃饭");
    }

    public void drink() {
        System.out.println("喝水");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

public class Cat extends Animal {
    public void catchMouse() {
        System.out.println("猫在抓老鼠");
    }
}

1
2
3
4
5
6

public class Dog extends Animal {
    public void housekeeping() {
        System.out.println("狗看家");
    }
}

1
2
3
4
5
6

public class Husky extends Dog {
    public void ruinRoom() {
        System.out.println("哈士奇在拆家");
    }
}

1
2
3
4
5
6

public class Lihua extends Cat {
}

1
2
3

public class Ragdoll extends Cat {
}

1
2
3

public class Teddy extends Dog {
    public void curls() {
        System.out.println("泰迪烫卷毛");
    }
}

1
2
3
4
5
6

public class Test {
    public static void main(String[] args) {
        //创建对象并调用方法
        //1.创建布偶猫的对象
        Ragdoll rd = new Ragdoll();
        rd.eat();
        rd.catchMouse();
        rd.drink();
        System.out.println("----------");

        //2.创建哈士奇的对象
        Husky h = new Husky();
        h.eat();
        h.ruinRoom();
        h.drink();
        h.housekeeping();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

三、子类能继承父类中的哪些内容（内存图/内存分析工具）

1.误区：
1）父类私有的东西，子类无法继承。
2）父类中非私有的成员，就被子类继承下来了。
2.构造方法：非私有不能；private不能。
父类的构造方法不能被子类继承。
3.成员变量：非私有能；private能(私有的虽然能继承但不能使用，可以使用GetSet)。
4.成员方法：虚方法表能；非虚方法表不能。
1）只有父类中的虚方法才能被子类继承。
2）虚方法：非private，非static，非final。
3）Object类有5个虚方法。
4）虚方法表图：

四、继承中：成员变量的访问特点：就近原则。

1.先在局部位置找，本类成员位置找，父类成员位置找，逐级往上。
2.如果出现了重名的成员变量：
1）System.out.println(name);//从局部位置开始往上找
2）System.out.println(this.name);//从本类成员位置开始往上找
3）System.out.println(super.name);//从父类成员位置开始往上找

五、继承中：成员方法的访问特点

1.直接调用和this调用满足就近原则。
2.super调用，直接访问父类。
3.方法的重写
1）当父类的方法不能满足子类现在的需求时，需要进行方法重写。
2）书写格式：在继承体系中，子类出现了和父类一模一样的方法声明，称子类这个方法是重写的方法。
3）@Override重写注解
@Override是放在重写后的方法上，校验子类重写时语法是否正确。
加上注解后如果有红色波浪线，表示语法错误。
建议重写方法都加@Override注解，代码安全优雅，可读性好。
4）方法重写的本质：子类的方法覆盖了从父类继承来的虚方法表里的方法。
5）方法重写注意事项和要求：
1、重写方法的名称、形参列表必须与父类中的一致。
2、子类重写父类方法时，访问权限子类必须大于等于父类（空着不写 3、子类重写父类方法时，返回值类型子类必须小于等于父类。
4、建议：子类重写的方法尽量和父类中的方法保持一致。
5、只有被添加到虚方法表中的方法才能被重写。
4.利用方法的重写设计继承结构
现在有三种动物：哈士奇、沙皮狗、中华田园犬
暂时不考虑属性，只要考虑行为。
请按照继承的思想特点进行继承体系的设计。

三种动物分别有以下的行为：
哈士奇：吃饭（吃狗粮）、喝水、看家、拆家
沙皮狗：吃饭（吃狗粮、吃骨头）、喝水、看家
中华田园犬：吃饭（吃剩饭）、喝水、看家

代码：

public class Dog {
    public void eat() {
        System.out.println("狗在吃狗粮");
    }

    public void drink() {
        System.out.println("狗在喝水");
    }

    public void housekeeping() {
        System.out.println("狗在看家");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

public class Husky extends Dog {
    //哈士奇有一个额外方法拆家
    public void ruinRoom() {
        System.out.println("哈士奇又在拆家了");
    }
}

1
2
3
4
5
6
7

public class Sharpei extends Dog {
    //沙皮狗吃狗粮和骨头
    //父类中的方法不能满足需求，需要进行重写

    @Override
    public void eat() {
        super.eat();//吃狗粮
        System.out.println("狗啃骨头");
    }
}
1
2
3
4
5
6
7
8
9
10

public class ChineseDog extends Dog {
    //父类中的方法不能满足需求，需要进行重写
    //中华田园犬不用父类中的代码，所以不需要super进行调用

    @Override
    public void eat() {
        System.out.println("吃剩饭");
    }
}
1
2
3
4
5
6
7
8
9

public class DogTest {
    public static void main(String[] args) {
        //创建对象并调用
        Husky h = new Husky();
        h.eat();
        h.drink();
        h.housekeeping();
        h.ruinRoom();

        ChineseDog cd = new ChineseDog();
        cd.eat();
        cd.drink();
        cd.housekeeping();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

六、继承中：构造方法的访问特点

1.父类中的构造方法不会被子类继承（类名不同）。但可以通过super调用。
2.子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。
1）原因：
1、子类在初始化的时候，有可能会使用到父类中的数据。
如果父类没有完成初始化，子类将无法使用父类的数据。
2、子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。
2）如何调用父类构造方法：
1、子类构造方法的第一行语句默认都是：super()，不写也存在，且必须在第一行。
2、如果想调用父类有参构造，必须手动写super进行调用。

七、this、super使用总结

1.this：理解为一个变量，表示当前方法调用者的地址值。
2.super：代表父类存储空间。
3.★★★this（…）调用本类其他构造方法。
虚拟机不会再添加super（）。写在第一行。一般用于设置默认值。
4.练习：带有继承结构的标准Javabean类
1）经理
成员变量：工号，姓名，工资，管理奖金
成员方法：工作（管理其他人），吃饭（吃米饭）
2）厨师
成员变量：工号，姓名，工资
成员方法：工作（炒菜），吃饭（吃米饭）

public class Employee {
    //1.类名见名知意
    //2.所有的成员变量都需要私有
    //3.构造方法（空参 带全部参数的构造）
    //4.get/set

    private String id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //工作
    public void work() {
        System.out.println("员工在工作");
    }

    //吃饭
    public void eat() {
        System.out.println("吃米饭");
    }
}

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

public class Manager extends Employee {
    private double bonus;

    //空参构造
    public Manager() {
    }

    //带全部参数的构造
    //父类+子类
    public Manager(String id, String name, double salary, double bonus) {
        super(id, name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("管理其他人");
    }
}

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
27
28

public class Cook extends Employee {
    public Cook() {
    }

    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }

    @Override
    public void work() {
        System.out.println("炒菜");
    }
}

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

public class Test {
    public static void main(String[] args) {
        //创建对象并赋值调用
        Manager m = new Manager("01", "王总", 20000, 8000);
        System.out.println(m.getId() + "," + m.getName() + "," + m.getSalary() + "," + m.getBonus());
        m.work();
        m.eat();

        Cook c = new Cook();
        c.setId("02");
        c.setName("大董");
        c.setSalary(8000);
        System.out.println(c.getId() + "," + c.getName() + "," + c.getSalary());
        c.work();
        c.eat();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18