Java初始化----高级篇

4. 加入继承以后的初始化

  我们用到上一篇java初始化基础篇的 3 中Combination类；（本例仅限于考虑与继承相关的初始化，仅仅从语言的角度写了本例）

public class SubClass extends Combination {

    private static int i = 99;

    static{
        System.out.println("i = " +i);
    }

    private static int j = 99;

    {
        System.out.println("j = " + j);
    }

    SubClass(){
        super();
        System.out.println("SubClass construct");
    }

    public static void main(String[] args) {
        new SubClass();
    }
}

  总体上来讲，应该还是按照前面所讲的三大步：

 1）加载SubClass类，初始化静态成员，

    在此处按照 3 引入组合之后的初始化的原则，应该在进入构造器方法体执行 super(), 即 父类的构造方法时， 再初始化父类的静态成员，但是引入继承以后此处发生了改变，

    extends 后面声明了父类的类型，此时我们就应该加载  父类的静态成员， 如果父类还有父类，直到根，所有的静态成员会从根类开始依次被初始化

    在本例继承层级为二层，所以先初始化父类Combination的静态成员，输出：

    Static Block
    Initialize Combination String s

    后初始化子类的静态成员，输出：

     i = 99

2） 初始化父类的实例域与父类构造器；输出：

    null
   I'M GOING INTO Constructor

   Initialize Static Field str1
   Initialize Instance Field str
   BaseInit constructor
   Combination construct

3）初始化子类的实例域与子类构造器（此时父类构造器已经执行完毕）；

   j = 99
  SubClass construct

5. 加入多态之后的初始化

    引入多态之后会出现在父类的构造器中调用已经被子类覆盖的方法，此时应该调用子类被覆盖后的方法；

   在Combination类:

       加入toString()方法：

    

 public String toString(){
        return "Combination";
    }

  在Subclass类：

     覆盖toString()方法：

 

public String toString(){
        return "SubClass";
    }

  在Combination类的构造器方法体： 多添加了toString()调用方法；

Combination(){
        System.out.println(toString());// 调用toString()方法
        baseInit = new BaseInit();
        System.out.println("Combination construct");

    }

    运行SubClass类，会发现调用父类构造器部分的输出：

    SubClass
    Initialize Static Field str1
    Initialize Instance Field str
    BaseInit constructor
    Combination construct

   发现并没有输出Combination，而是调用了子类的toString()方法输出SubClass；

6 加入final后的初始化；

  

public class Final {
    
    private static Random random = new Random();
    private final int base_Int = random.nextInt(23);
    private static final int BASE_INT = random.nextInt(23);

    public static void main(String[] args) {

        System.out.println(Final.BASE_INT);
        Final instance = new Final();
        System.out.println(instance.base_Int);
        System.out.println(instance.BASE_INT);
        Final instance_1 = new Final();
        System.out.println(instance_1.base_Int);
        System.out.println(instance_1.BASE_INT);

    }
}

  运行结果发现：

   由于BASE_INT是static的，在第一次引用时，就被其类的static域都被初始化，用new创建对象时，只会对非static域进行初始化，故BASE_INT在运行期间值一直保持不变；

  但是非static的base_Int确会因每次new对象，而再次被初始化，发生改变；