【Java SE】继承与组合

🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

1. 再谈初始化

在【Java SE】深入理解static关键字这一期中，我们提到代码块，本期重点理解这些代码块实现的顺序
【内容回顾】

【测试代码】

public class Student {
    public String name;
    public int age;
    public int sno;

    public Student(String name, int age, int sno) {
        this.name = name;
        this.age = age;
        this.sno = sno;
        System.out.println("我是构造方法！");
    }
    {
        System.out.println("我是实例代码块/非静态代码块/构造代码块");
    }
    static {
        System.out.println("我是静态代码块");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三",18,202110);
        System.out.println("--------分割线--------");
        Student student2 = new Student("小碗",21,202111);
    }
}

【运行结果】

通过上述代码和结果，可以清晰看到先执行静态代码块再执行实例化代码块最后执行构造方法，当第二对象创建时，静态代码块不再执行，执行实例化代码块最后执行构造方法，我们得出结论：

【总结】
(1) 静态代码块先执行，且只执行一次，在类加载阶段执行
(2) 只有对象创建时，才会执行实例代码块，实例代码块执行完成后，构造方法执行
在继承关系中，这些代码块的执行顺序又是怎么样呢？我们一起看看下面的例子吧~
【测试代码】

public class Parent {
    public String name;
    public int age;
    public int sno;

    public Parent(String name,int age, int sno){
        this.name = name;
        this.age = age;
        this.sno = sno;
        System.out.println("Parent父类构造方法");
    }
    {
        System.out.println("Parent父类实例代码块/构造代码块/非静态代码块");
    }
    static {
        System.out.println("Parent父类静态代码块");
    }
}

public class Child extends Parent{

    public Child(String name, int age,int sno) {
        super(name, age, sno);
        System.out.println("Child子类构造方法");
    }
    {
        System.out.println("Child子类实例代码块/构造代码块/非静态代码块");
    }
    static {
        System.out.println("Child子类静态代码块");
    }
}

public class Test {
    public static void main(String[] args) {
        Child child1 = new Child("张三",18,202110);
        System.out.println("--------分割线--------");
        Child child2 = new Child("小碗",21,202111);
    }
}

【运行结果】

通过上述代码和结果，可以清晰看到先执行父类静态代码块再执行子类静态代码块，再执行父类实例化代码块和父类执行构造方法最后执行子类实例化代码块和子类执行构造方法，当第二个对象创建时，静态代码块不再执行，执行父类实例化代码块和执行父类构造方法再执行子类实例化代码块和子类执行构造方法，我们得出结论：

【总结】
(1) 父类静态代码块优先于子类静态代码块执行，且是最早执行只执行一次
(2) 父类实例代码块和父类构造方法紧接着执行
(3) 子类的实例代码块和子类构造方法紧接着再执行

2. 再谈protected关键字

2.1 子类可见性

Java中引入了访问限定符可以实现封装的特性，主要限定类或者类中成员能否在类外或者其他包中被访问
【内容回顾】

其中protected关键字允许在不同包中子类访问，涉及到继承
【测试代码】
在同一包内，父类中不同访问权限的成员，在子类中的可见性

//extend1包中
public class Parent {
    private int a;
    int b;
    protected int c;
    public int d;
}

public class Child extends Parent{
    public void method() {
        super.a = 1; //编译报错,父类private成员只能在同一包同一类即父类中访问
        super.b = 2;//父类中默认访问权限修饰成员在相同包子类中可以直接访问
        super.c = 3;//父类中成员protected在相同包子类中可以直接访问
        super.d = 4;//父类中成员public在相同包子类中可以直接访问
    }
}

【运行结果】

分析：报错，父类成员a被private修饰，无法在子类中访问，其它修饰符在同一个包均可在子类中访问父类成员
在不同包内，父类中不同访问权限的成员，在子类中的可见性

//extend1包中
public class Parent {
    private int a;
    int b;
    protected int c;
    public int d;
}

//extend2不同包内
public class Child1 extends Parent{
    public void method() {
        super.a = 1; //编译报错,父类private成员只能在同一包同一类即父类中访问
        super.b = 2; //父类中默认访问权限修饰成员在不同包子类中不能直接访问
        super.c = 3; //父类中成员protected在不同包子类中可以直接访问
        super.d = 4; //父类中成员public在不同包子类中可以直接访问
    }
}

public class Test {
    public static void main(String[] args) {
        Child1 child1 = new Child1();
        child1.method();
        System.out.println(child1.a); //编译报错,父类private成员只能在同一包同一类即父类中访问
        System.out.println(child1.b); //父类中默认访问权限修饰成员在不同包其他类中不能直接访问
        System.out.println(child1.c); //父类中protected成员在不同包其他类中不能直接访问
        System.out.println(child1.d); //父类中public成员在不同包其他类中可以直接访问
    }
}

通过上述代码，相信我们更能理解这4种访问修饰限定符的范围，其中protected可以访问不同包中的子类，但是对于不同包的其它类则不能访问
【注意事项】
父类private成员变量在子类中不能直接访问，但也继承到子类中，只是不能直接访问

2.2 访问修饰限定符的选择

什么时候下用哪一种访问修饰限定符呢?
我们为什么要用访问修饰限定符，是想类尽量实现封装特性，即隐藏内部实现细节，只暴露出必要的信息给类的调用者
因此我们在使用的时候应该尽可能的使用比较严格的访问权限，有以下原则：
(1) 如果一个方法能用 private，就尽量不要用 public
(2) 该类提供的字段/方法到底给 “谁” 使用(是类内部自己用，还是类的调用者使用， 还是子类使用)

3. 继承与组合

【组合】和继承类似，组合也是一种表达类之间关系的方式，也能达到代码重用的效果，但组合并没有涉及到特殊的语法，仅仅是将一个类的实例作为另外一个类的字段
继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物，鸟是动物
组合表示对象之间是has-a的关系，比如：汽车是由轮胎、方向盘、发动机等组成
【组合代码】

//轮胎类
class Tire {
    //...
}
//方向盘类
class SteeringWheel {
    //...
}
//发动机类
class VehicleSystem {
    //...
}

class Car {
    private Tire tire; //可以复用轮胎中的属性和方法
    private SteeringWheel sw; //可以复用方向盘中的属性和方法
    private VehicleSystem vs; //可以复用发动机中的属性和方法
}

【继承代码】

//小米SU7是汽车
class SpeedUltra extends Car {
  //将汽车中包含的轮胎、方向盘、发动机全部继承下来
}

【选择】组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合
本期内容到这里结束啦~以下是本期内容回顾：

下期再见啦~