java继承中谈“初始化和final”

---

七、再谈初始化

继承关系上的执行顺序

代码如下（示例）：
父类：

public class Fu9 {
    public Fu9(){
        System.out.println("我是父类的构造方法");
    }

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

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

子类：

public class Zi9 extends Fu9{
    public Zi9(){
        System.out.println("我是子类的构造方法");
    }

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

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

    public static void main(String[] args) {
        Zi9 zi=new Zi9();
        System.out.println("==================");
        Zi9 z2=new Zi9();
    }
}

输出结果应该为什么呢？解释如下：

八、protected关键字

在类和对象章节中，为了实现封装特性，java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。在这里把之前的表格搬运过来，方便大家理解：

下面通过一个例子来观察基类中不同访问权限修饰的成员在子类中能否使用—可见性：
基类：

public class Base7 {
    public int pub;
    int def;
    protected int pro;

    private int pri;


    public void methodPublic(){


    }

    protected void methodProtected(){

    }

    void methodDefault(){

    }

    private void methodPrivate(){

    }
}

同一个包中的子类：


不同包中的子类：

不同包中的非子类：

九、继承方式

在现实生活中，事物之间的关系是非常复杂，灵活多样的。但是在java中只支持以下几种继承方式：

C++：支持多继承—>里面有很多坑，假设A类和B类中都还有一个成员变量a，那么在C类中就不知道去访问哪个类里面的a。
注意：即使如此，并不希望类之间的继承层次太复杂，一般我们不希望出现超过三层的继承关系，如果继承层次太多，就需要考虑对代码进行重构了。
如果想从语法上进行限制继承，就可以使用final关键字。

十、final关键字

final关键字可以用来修饰变量，成员方法以及类。

1.修饰变量或字段，表示常量（即不可修改）

b被final修饰，认为b是一个常量，常量是不能被修改的。
这时联想到一个问题：

是上面那一行可以通过编译还是底下那一行？

答案是下面那一行。
注意：final在此处修饰的是array，表明该引用时不能再去引用其他的数组了类似于C语言中的const。

2.修饰类：表示此类不能被继承

十一、继承和组合

汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。
示例如下：
Tire类：

public class Tire {
    private double r;

    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }
}

Engine类：

public class Engine {
    public void Start(){
        System.out.println("发动机启动");
    }

    public void Stop(){
        System.out.println("发动机停止");
    }

    public void method(){

    }
}

Benz类：

public class Benz extends Car{
}

Car类：

public class Car {
    private String name;
    protected Tire trie;
    protected Engine engine;

    public void Start(){
        engine.Start();
    }

    public void Stop(){
        engine.Stop();
    }

    //...
}

组合实现代码复用，对象与对象之间耦合能小一点，只要被包含类，内部修改了，但是不修改对外的方法，对包含的类是没有任何影响的。
组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据与应用场景来选择，假如写车载系统类，那么车载系统和车就是组合关系，加入写一个奔驰类，那么奔驰和车就是继承关系，一般建议：能用组合尽量用组合。