Java继承学习小结

一、继承中构造方法的关系

public class ConstructionMethodTest {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        System.out.println("-----------");
        SubClass subClass2 = new SubClass(1);
    }
}

class SuperClass {
    public SuperClass() {
        System.out.println("父类的无参构造方法");
    }

    public SuperClass(int i) {
        System.out.println("父类的带参构造方法");
    }
}

class SubClass extends SuperClass {
    public SubClass() {
        System.out.println("子类的无参构造方法");
    }

    public SubClass(int i) {
        System.out.println("子类的带参构造方法");
    }
}

执行结果：

父类的无参构造方法
子类的无参构造方法
---------------
父类的无参构造方法
子类的带参构造方法

在上述代码中，SubClass继承SuperClass，当创建SubClass对象的时候，会先调用父类的构造方法，然后调用子类的构造方法。
比较SubClass subClass = new SubClass()和SubClass subClass2 = new SubClass(1)，发现不管子类调用的是无参还是带参的构造方法，都会先调用父类的无参构造方法。

总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。子类每一个构造方法的第一条语句默认都是：super()

二、继承关系中代码块的执行顺序

public class ConstructionMethodTest {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
    }
}

class SuperClass {

    static {
        System.out.println("静态代码块SuperClass");
    }

    {
        System.out.println("构造代码块SuperClass");
    }

    public SuperClass() {
        System.out.println("构造方法SuperClass");
    }
}

class SubClass extends SuperClass {

    static {
        System.out.println("静态代码块SubClass");
    }

    {
        System.out.println("构造代码块SubClass");
    }

    public SubClass() {
        System.out.println("构造方法SubClass");
    }
}

执行结果：

静态代码块SuperClass
静态代码块SubClass
构造代码块SuperClass
构造方法SuperClass
构造代码块SubClass
构造方法SubClass

在执行过程中，会先加载父类的静态代码块，然后加载子类的静态代码块；在子类调用构造方法之前，先调用父类的构造方法，而构造代码块顺序先于构造方法，因此先调用父类的构造代码块，然后调用父类的构造方法；接下来调用子类的构造代码块和子类的构造方法。

总结：一个类中代码块的执行顺序 静态代码块 > 构造代码块 > 构造方法；静态代码块在类加载时就执行；在调用构造方法之前先调用构造代码块。

三、只声明不赋值是否会加载类

public class ConstructionMethodTest {
    public static void main(String[] args) {
        System.out.println("-----------------");
        SubClass subClass  = new SubClass();
        System.out.println("-----------------");
    }
}

class SuperClass {

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

}

class SubClass extends SuperClass {

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

结果：

-----------------
父类的静态代码块
子类的静态代码块
-----------------

这个结果很显然，但是把SubClass subClass = new SubClass() 修改为 SubClass subClass；对subClass只进行声明，不赋值。
结果：

-----------------
-----------------

结果显示，对类SubClass ，并没有进行类的加载。
对编译完成的SubClass.class进行反编译，可以看到如下图：

在反编译的代码中，SubClass subClass的声明操作被编译器优化掉。

总结：Java编译器在编译过程中会根据一定的机制对代码进行优化。
最常见的优化之一就是对常量的优化，比如

int i = 1+2;
编译之后会被优化成
int i = 3；