• 不就是Java吗之 继承

    继承

    一、继承

    1.1 为什么需要继承

    Java使用类来对现实世界进行描述，那么现实世界错综复杂，不同事务之间可能会有联系，会有共同点。比如修猫还有修狗，都能吃，都能睡，都能叫。那么我们可以用类来表示修猫和修狗

    class Cat {
    public String name;
    public int age;
    public double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
    public void mew() {
        System.out.println(this.name + "正在喵喵喵!");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    class Dog {
    public String name;
    public int age;
    public double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
    public void bark() {
        System.out.println(this.name + "正在汪汪汪!");
    }
}

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

    我们可以看到，他们都有共同的属性

    public String name;
public int age;
public double weight;

    • 1
    • 2
    • 3

    也有共同的方法

    public void sleep() {
    System.out.println(this.name + "正在睡觉!");
}
public void eat() {
    System.out.println(this.name + "正在吃饭!");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    image-20220527175942386

    那么我们能否把这些共同点抽取出来，然后能多次使用呢？这就需要我们的继承了

    1.2 继承

    继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

    其实继承就是：对共性的抽取，从而达到了代码的复用

    image-20220527175909365

    上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

    从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态(后序讲)。

    1.2.1 语法

    修饰符 class 子类 extends 父类 {
 // ... 
}
其中，子类又叫做派生类，父类又叫做基类/超类

    • 1
    • 2
    • 3
    • 4

    比如：

    class Cat extends Animalc {
    // ...
}

    • 1
    • 2
    • 3

    那么我们就可以对猫类、狗类重新设计了

    class Animal {
    public String name;
    public int age;
    public double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.name + "正在喵喵喵!");
    }
}

class Dog extends Animal {
    public String color;

    public void bark() {
        System.out.println(this.name + "正在汪汪汪!");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sex = "雌性";//可以对子类的属性进行赋值
        cat.name = "大傻瓜";//也可以对父类继承下来的属性进行赋值
        cat.age = 3;
        cat.weight = 16.0;
        cat.eat();//可以调用父类继承下来的方法
        cat.sleep();
        cat.mew();//也可以调用自己的方法
        System.out.println("-----------------");
        Dog dog = new Dog();
        dog.color = "黄色";
        dog.name = "大笨蛋";
        dog.age = 4;
        dog.weight = 18.8;
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}


    • 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

    image-20220527185124506

    在这里我们要注意两点：

    1. 子类会将父类当中的成员变量或者成员方法继承到子类当中
    2. 子类继承父类之后，最好要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

    那么我们把访问权限改成私有呢？

    class Animal {
    private String name;
    private int age;
    private double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.name + "正在喵喵喵!");
    }
}

class Dog extends Animal {
    public String color;

    public void bark() {
        System.out.println(this.name + "正在汪汪汪!");
    }
}

    • 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

    我们可以看到，name属性访问不了了？这难道是因为没有被继承？

    image-20220528205823153

    不是，是因为这几个属性被设置成私有的，在类外访问不了。我们需要编写getter setter方法，在类外才能实现

    class Animal {
    private String name;
    private int age;
    private double weight;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.getName() + "正在喵喵喵!");
    }
}

class Dog extends Animal {
    public String color;

    public void bark() {
        System.out.println(this.getName() + "正在汪汪汪!");
    }
}

    • 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

    1.3 父类成员访问

    在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

    1.3.1 子类访问父类的成员变量

    1.3.1.1 子类和父类不存在同名成员变量

    class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base {
    public int c = 3;

    public void method() {
        System.out.println(a);//访问从父类继承的a:1
        System.out.println(b);//访问从父类继承的b:2
        System.out.println(c);//访问子类自己的c:3
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}


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

    image-20220527191950847

    1.3.1.2 子类和父类成员变量同名

    class Base2 {
    public int a = 1;
    public int b = 2;

    public void method() {
        System.out.println("Base2::method");
    }
}

class Derived2 extends Base2 {
    public int a = 3;
    public int c = 4;

    public void method(int a) {
        System.out.println("Derived::method");
    }

    public void display() {
        System.out.println(a);//3:子类里面也有的时候，优先访问子类
        System.out.println(b);//2:子类里面没有的时候，去父类里面找
        System.out.println(c);//4：子类里面有父类里面没有的，去子类里面找
        //System.out.println(d);//子类当中也没有，父类当中也没有->报错
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived2 derived2 = new Derived2();
        derived2.display();
    }
}

    • 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

    在子类方法中 或者 通过子类对象访问成员时：

    • 如果访问的成员变量子类中有，优先访问自己的成员变量。
    • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
    • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的，即：子类将父类同名成员隐藏了。成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

    那么我们要访问父类的成员变量，该怎么办呢？

    这时候我们就需要用一个关键字super，他的作用是在子类方法中访问父类的成员

    大家都说super代表父类对象的引用，但是不太准确。super其实就是个普通的关键字，是来帮助别人或者程序员知道访问父类成员的，起到了易读的操作

    所以我们就可以这样写：

    public void display() {
        System.out.println("父类里面的a:" + super.a);
        System.out.println("子类里面的a:" + this.a);
        System.out.println("父类里面的b:" + super.b);
        System.out.println("父类里面的b:" + this.b);//因为父类里面有b，子类里面没有b，所以也可以用this
        System.out.println("子类里面的c:" + this.c);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    image-20220527194608521

    image-20220527194346936

    1.3.2 子类中访问父类的成员方法

    1.3.2.1 成员方法名字不同

    成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

    class Base3 {
    public void methodA() {
        System.out.println("Base3::methodA()");
    }
}

class Derived3 extends Base3 {
    public void methodB() {
        System.out.println("Derived3::methodB()");
    }

    public void display() {
        methodA();//访问父类的A
        methodB();//访问子类的B
        //methodC();//父类子类都没有->报错
    }
}

public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.display();
    }
}


    • 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

    1.3.2.2 成员方法名字相同

    通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用的方法所传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法的原型一致(这就是重写，后面讲)，则只能访问到子类的，父类的无法通过派生类对象直接访问到，需要借助super关键字

    class Base4 {
    public void method1() {
        System.out.println("Base4::method1()");
    }

    public void method2() {
        System.out.println("Base4::method2()");
    }
}

class Derived4 extends Base4 {
    public int a = 10;

    public void method1(int a) {
        System.out.println("Derived4::method1(int a)");
    }

    public void method2() {
        System.out.println("Derived4::method2()");
    }

    public void display() {
        method1();//没有参数->调用父类的method1方法
        method1(a);//有参数->调用子类的method1方法
        super.method1();//没有参数->调用父类的method1方法,super也不好使
        method2();//没有super->调用子类的method2方法
        super.method2();//有super->调用父类的method2方法
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Derived4 derived4 = new Derived4();
        derived4.display();
    }
}


    • 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

    image-20220528150121592

    我们要注意的是，其实这里面是发生了函数重载的。那有的同学就想起来了，函数重载不是在方法之间产生的吗，而且当初我们是在一个类里面实现的啊？在两个类里面也可以实现继承？

    要在两个类里面的方法实现继承的话，必须这两个类是继承关系！！！

    1.4 super关键字

    super关键字的主要功能是：在子类方法中访问父类的成员(成员变量、成员方法)。

    super代表父类对象的引用，其实是不准确的。它起到的作用就是：当别人看见这个关键字之后，知道我是在访问父类的成员，增加可读性

    class B extends A {
    char a1;
    public void func() {
        super.a1 = 97;//并未改变a1的值
    }
}
public class TestDemo5 {
    public static void main(String[] args) {
        B b = new B();
        b.func();
        System.out.println(b.a1);//打印不出来的东西
        A a = new A();
        System.out.println(a.a1);//100

    }
}


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

    image-20220528155412437

    但是要注意：super是不能在静态方法里面使用的

    public static void func() {
        System.out.println(super.a);
    }

    • 1
    • 2
    • 3

    image-20220528151054009

    我们刚才也知道了super的几个用法：

    1. super.data：访问父类当中的成员变量
    2. super.func()：访问父类当中的成员方法

    其实super还有一个用法：子类构造父类的时候会用上，这就是我们接下来要讲的

    1.5 子类构造方法

    当构造子类的时候，一定要先帮父类进行构造。

    父类：

    //构造方法
    public Animal(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    子类：

    //构造方法
    public Cat(String name,int age,double weight,String sex) {
        //先帮助父类构造
        super(name,age,weight);
        //再帮助子类构造
        this.sex = sex;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    //构造方法
    public Dog(String name, int age, double weight, String color) {
        //先帮助父类构造
        super(name, age, weight);
        //再帮助子类构造
        this.color = color;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    注意事项：

    1. super必须放在第一行

      public Cat(String name,int age,double weight,String sex) {
        System.out.println("super不放在第一行当然是不行的");
        //先帮助父类构造
        super(name,age,weight);
        //再帮助子类构造
        this.sex = sex;
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

      image-20220528162949217

    2. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法

      原型：

      public Cat() {
    super();
}

      • 1
      • 2
      • 3

      这里面的super可以省略

      如果父类构造方法是带有参数的，此时编译器不会再给子类生成默认的构造方法，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

    3. super只能在构造方法中出现一次

      class Animal {
    private String name;
    private int age;
    private double weight;
    
    //构造方法
    public Animal(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    public Animal(String name) {
        this.name = name;
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.getName() + "正在喵喵喵!");
    }

    //构造方法
    public Cat(String name,int age,double weight,String sex) {
        //不能出现两个super
        super(name,age,weight);
        super(name);
        
        this.sex = sex;
    }
}


      • 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

      image-20220528163841858

    4. super不能和this同时出现

      //构造方法
    public Cat(String name,int age,double weight,String sex) {
        //super不能和this同时出现
        super(name,age,weight);
        //this(name);
        
        this.sex = sex;
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

      image-20220528163955064

    1.6 super 和 this

    super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

    相同点：都是Java中的关键字

    1. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
    2. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

    不同点：

    1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成
      员的引用
    2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
    3. this是非静态成员方法的一个隐藏参数，super不是隐藏的参数
    4. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造
      方法中出现
    5. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

    1.7 再谈初始化

    在之前，我们讲过了实例代码块、静态代码块、构造方法。那么我们浅浅的复习一下

    执行时间：静态代码块>实例代码块>构造方法

    1. 静态代码块只会执行一次，在类加载阶段执行
    2. 实例代码块只会在有对象创建的时候才执行

    那么我们学习了继承，父类中可以有静态代码块、实例代码块、构造方法，子类中也可以有静态代码块、实例代码块、构造方法。那么他们执行的先后顺序也跟之前的一样吗？我们举个栗子：

    class Person {
    public String name;
    public int age;

    //构造方法
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类的构造方法");
    }

    //实例代码块
    {
        System.out.println("父类的实例代码块");
    }

    //静态代码块
    static {
        System.out.println("父类的静态代码块");
    }
}

class Student extends Person {
    public int id;

    //构造方法
    public Student(String name,int age,int id) {
        super(name,age);
        this.id = id;
        System.out.println("子类的构造方法");
    }

    //实例代码块
    {
        System.out.println("子类的实例代码块");
    }

    //静态代码块
    static {
        System.out.println("子类的静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student("孙答应",56,001);
        System.out.println("-----------------");
        Student student2 = new Student("静白师太",66,002);
    }
}


    • 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

    运行结果：

    image-20220528200308308

    父类的静态代码块
子类的静态代码块
父类的实例代码块
父类的构造方法
子类的实例代码块
子类的构造方法
-----------------
父类的实例代码块
父类的构造方法
子类的实例代码块
子类的构造方法

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    那么我们看运行结果，我们可以归纳出：

    1. 静态代码块依然先执行，其中父类的静态代码块比子类的静态代码块先执行
    2. 然后执行父类的实例代码块和静态代码块
    3. 再然后执行子类的实例代码块和构造方法
    4. 第二次实例化对象的时候，父类和子类的静态代码块都不再执行

    1.8 protect关键字

    image-20220528201148867

    如果产生了继承关系，子类就可以访问到父类里面被protct修饰的成员变量

    举个栗子：

    父类：

    public class B {
    private int a;//私有的：只能在当前类中访问
    protected int b;//继承权限：产生继承关系，子类就可以访问父类protected修饰的成员变量
    public int c;//哪里都可以访问
    int d;//默认权限：在同一个包中都可以访问
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    同一个包下，产生继承关系的D类：

    public class D extends B {
    public void method() {
        //super.a = 10;//编译报错：父类中a为private属性，只能在父类中使用
        super.b = 20;//父类中b为protected属性，由于B D为继承关系，父类中protected成员在子类中也可以访问
        super.c = 30;//父类中c为public属性，哪里都可以访问
        super.d = 40;//父类中d为default属性，可以在当前包中任何位置访问
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    不同包下，产生继承关系的C类：

    public class C extends B {
    public void method() {
        //super.a = 10;//编译报错：父类中a为private属性，只能在父类中使用
        super.b = 20;//父类中b为protected属性，由于B D为继承关系，父类中protected成员在子类中也可以访问
        super.c = 30;//父类中c为public属性，哪里都可以访问
        //super.d = 40;//编译报错：父类中d为default实行，只能在同一个包中访问
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    不同包下，未产生继承关系的Test类：

    public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.method();

        //System.out.println(a);//编译报错：父类中a为private属性，只能在父类中使用
        //System.out.println(b);//父类中b为protected修饰，未产生继承关系，不能访问
        System.out.println(c);//父类中public成员在不同的包不同的类中都可以访问
        //System.out.println(d);//父类中d为default修饰，在其他包中就不可以访问了
    }
}


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

    他们的关系我已经截图标记出来了

    image-20220528205656865

    那么我们现在学会了好几种权限，那到底什么时候用哪一种呢？

    教给大家一种最直接的办法：

    所有的成员属性全部设置成private，将所有的方法设置成public

    1.9 Java当中的继承方式

    Java只支持以下几种继承方式：

    image-20220528210332738

    1.10 final关键字

    final是一个关键字，可以用于修饰类，成员变量，成员方法。

    特点：

    1. 它修饰的类不能被继承。

      Animal类：

      final public class Animal {
    
}

      • 1
      • 2
      • 3

      image-20220528210809295

      Birds类：

      public class Bird extends Animal {
    
}

      • 1
      • 2
      • 3

      image-20220528210916512

    2. 它修饰的成员变量是一个常量。被final修饰的常量名称,所有字母都大写

      final int SIZE = 10;//当前的SIZE后续就不能被修改了

      • 1

    3. 它修饰的成员方法是不能被子类重写的。(后续)

    1.11 继承与组合

    继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物

    组合表示对象之间是has-a的关系，组合就是把另一个类的类型定义的新变量作为成员，比如：汽车

    那我们举个栗子：汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。

    class Tire {
    
}

class Engine {
    
}

class VehicleSystem {
    
}

class Car {
    //这就叫复用
    private Tire tire;
    private Engine engine;
    private VehicleSystem vehicleSystem;
}

class Baoma extends Car {
    //宝马可以继承Car里面的所有属性
}

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

    栗子2：

    class Money {
    
}

class Student {
    public Money money;
}

class Teacher {
    public Money money;
}

class School {
    public Student[] student;
    public Teacher[] teacher;
}

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

  • 相关阅读:
    PHP如何持续监听Redis的消息订阅并推送到前端？
    第二证券：长期停牌一般是多久？
    尚医通 (二十三) --------- MongoDB 入门
    Python学习笔记--自定义容器（Container）
    Java Character.SubSet equals()方法具有什么功能呢?
    java计算机毕业设计校园表白墙服务平台源码+系统+数据库+lw文档
    uniapp存值和取值，获取登录凭证 code方法
    分布式主键算法
    深入理解Java正则表达式及其应用
    对话框管理器第五章：将非模态对话框转为模态
  • 原文地址：https://blog.csdn.net/m0_53117341/article/details/126091452