“继承与组合：代码复用的两种策略“

White graces：个人主页

今日诗词:"故人陆续凋零，好似风中落叶啊"

 内容推荐:“掌握类与对象，点亮编程之路“(下)

专栏推荐:“Java入门指南：从零开始学习Java编程”

---

快去学习

 

目录

思维导图

一.继承

1.什么是继承？

2.继承的语法

 3.子类访问父类优先级

1.super关键字

4.子类如何初始化

5.protected关键字

6.继承关系

7. final关键字

二.组合

三.结语+美图分享

---

思维导图

 

一.继承

1.什么是继承？

生活中的继承一般和财产遗产挂钩，这些东西还有重复使用的价值，一般这个过程就是继承

Java中的继承也类似：将许多成员共有的特性写在一起，需要使用继承（调用）即可，不需要重复书写代码。

2.继承的语法

继承需要用到关键字：extends

继承是针对类的

继承语法：B extends A，这个例子表示B类继承A类。

我们来看下面的图片⬇️⬇️

​

此时就会出现两个概念：父类，子类

我们把A称为父类，B称为子类

 3.子类访问父类优先级

规则：子类父类变量同名，采用就近原则

               不同名正常访问即可

我们来看下面的图片⬇️⬇️

​

 运行结果

​

这时候大家肯定会想，如果我就想访问父类的成员，该怎么办呢？

因此Java提供了super关键字，用于在子类中访问父类的成员

1.super关键字

作用一：用于在子类中访问父类的成员

​

4.子类如何初始化

一般情况的初始化我们已经学会了，可以参考：调用构造方法初始化

子类的初始化有所不同，父子父子，先有父再有子。

想要初始化子类，要先帮助父类进行初始化。

super关键字作用二：在子类中，调用父类的构造方法，帮助父类初始化

有了构造方法 != 初始化了，

初始化可以大致理解成赋值，而构造方法只是一个方法，并没有赋值。

下面我们来看看如何子类初始化⬇️⬇️

package Test1;
class Animal {
    String name;
    int age;
    public Animal(String name, int age) { //父类的构造方法
        this.name = name;
        this.age = age;
        System.out.println("父类初始化"); //这是个标记，用于直观看到父类初始化
    }
}
class Dog extends Animal {
    public Dog(String name, int age) { //将Ikun和25传进来
        super(name, age); //通过super关键字再把姓名、年龄给父类（赋值），帮助父类初始化
        System.out.println("子类初始化"); //这是个标记，用于直观看到子类初始化
    }

    public void bark() { //子类自己特有的构造方法
        System.out.println("正在汪汪叫");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog =new Dog("Ikun",25);
        //这里我们只实例化对象，并没有调用类里面的方法
    }
}

当我们执行程序的时候，编译器会自动执行构造方法进行初始化，而不是我们去调用执行

执行特点：先执行父类，再执行子类。

还有两种初始化方法：静态代码块初始化、实例代码块初始化（不常用）

于是又会出现一个问题，三个同时出现，先执行哪一个呢？

package Test1;
class Animal {
    String name;
    int age;
    public Animal(String name, int age) { //父类构造方法
        this.name = name;
        this.age = age;
        System.out.println("父类构造代码块");
    }
    static { //父类静态代码块
        System.out.println("父类静态代码块");
    }
    {  //父类实例代码块
        System.out.println("父类实例代码块");
    }
}
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
        System.out.println("子类构造代码块");
    }
    static { //子类静态代码块
        System.out.println("子类静态代码块");
    }
    {  //子类实例代码块
        System.out.println("子类实例代码块");
    }
    public void bark() {
        System.out.println("正在汪汪叫");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog =new Dog("Ikun",25);
        System.out.println("==================");
        Dog dog1 = new Dog("大黄",5);
        //这里我们只实例化对象，并没有调用类里面的方法
    }
}

运行结果

​

结论

1.静态代码块最早执行，且只执行一次

2.然后执行父类实例代码块（先）和父类构造代码块（后）

3.再执行子类实例代码块（先）和子类构造代码块（后）

5.protected关键字

继上篇知识，我们知道protected是访问修饰限定符

访问范围：1.同一包的同一类

                  2.同一包的不同类

                  3.不同包的子类

​

 6.继承关系

继承一般分为三种：单继承、多层继承、多继承。

我们直接画图演示，看完你就明白了。

​

 

Java支持：单继承、多层继承

        不支持：多继承（一个孩子不可能有两亲生父亲）

7. final关键字

修饰范围：方法、成员变量、类。

作用

修饰类：此类不能被继承

修饰变量：则它的值不能被更改，变成常量了

修饰方法：此方法不能被重写（不是重载），后面会说

二.组合

由于Java不支持多继承，当我有时候又会碰到这样的情况，这时候组合就有妙用了

比如一辆汽车，由轮胎、发动坤、车载系统.......构成

组合把类创建的对象当作成员变量

package Test1;
class Tire{ //轮胎

}

class Engine{ // 发动机类

}

class VehicleSystem{ // 车载系统类

}
class Car{
    public Tire tire; // 可以复用轮胎中的属性和方法
    public Engine engine; // 可以复用发动机中的属性和方法
    public VehicleSystem vs; // 可以复用车载系统中的属性和方法
    
}
class Benz extends Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
    
}
public class Test1 {
    public static void main(String[] args) {
        Benz benz = new Benz();
    }
}

这样就通过组合模拟出类似多继承的效果了，这种效果不是很好，后面会使用接口真正实现多继承

以上就是这篇文章的所有内容了

谢谢阅读本文，希望你能从中获得一些启发和思考 

三.结语+美图分享

 

✨谢谢你的阅读和耐心！祝愿你在编程的道路上取得更多的成功与喜悦！"✨

⭐️点赞收藏加关注，学习知识不迷路⭐️

✔️✔️✔️✔️

⛳️ 点赞☀️收藏 ⭐️ 关注！

⛳️ 点赞☀️收藏 ⭐️ 关注！

⛳️ 点赞☀️收藏 ⭐️ 关注！

‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️‍♂️