Java类的初始化过程

类的组成：

• 静态、非静态成员变量
• 静态、非静态成员方法
• 静态、非静态内部类
• 静态、非静态代码块
• 内部接口
• 内部类
• 内部抽象函数

查看一下类包含以上信息是编译之后去除注释和无用的import生成的class文件结构：
非静态的代码块会合并（按照代码块出现的顺序合并）放置到每个构造方法开头，静态的代码块江湖合并到一个静态的代码块中（按照出现的顺序排列）。如下代码：

Dog.java

public class Dog extends Animal{
    public String name;
    public static int age=10;
    int weight=10;

    // static code block 1
    static {
        System.out.println("静态代码块：1");
    }
    // code block 1
    {
        System.out.println("代码块：1");
    }
    // static code block 2
    static {
        System.out.println("静态代码块：2");
    }
    // code block 1
    {
        System.out.println("代码块：1");
    }

    public Dog() {
    }

    public Dog(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public static void printAge() {
        System.out.println("dog age is "+ age);
    }
    class A {

    }
    abstract class B{

    }

    interface C {

    }
}

Dog.class

import learn.java.Animal;
public class Dog extends Animal {
    public String name;
    public static int age=10;
    int weight = 10;

    public Dog() {
        System.out.println("代码块：1");
        System.out.println("代码块：1");
    }

    public Dog(String name, int weight) {
        System.out.println("代码块：1");
        System.out.println("代码块：1");
        this.name = name;
        this.weight = weight;
    }

    public static void printAge() {
        System.out.println("dog age is " + age);
    }

    static {
        System.out.println("静态代码块：1");
        System.out.println("静态代码块：2");
    }
     interface C {
    }

    abstract class B {
        B() {
        }
    }

    class A {
        A() {
        }
    }
}

什么时候加载类？

个人觉得类被引用时会被加载，不引用不会被加载，类引用分为：
* 静态引用（调用静态的变量和方法）
* 实例引用（new 一个对象）
* 父类在子类被引用

类的初始化顺序

• 静态引用初始化

  只在第一次加载，只初始化静态成员变量和运行静态代码块，它们按照出现的顺序执行

• 实例化引用初始化

  1.先执行静态引用的初始化过程（如果之前没有加载过）
  2.然后非静态成员变量的赋值初始化，再执行构造方法。因为非静态代码块编译后合并到了构造方法的最开始，所以先执行非静态代码块的代码，然后再执行构造方法。
  3.如果类中包含内部类，也是按照上面引用的方式进行加载的如果没有被引用则不会被加载。

• 父类在子类被引用初始化

  1. 先执行父类静态引用的初始化，再执行子类静态引用的初始化。
  2. 接着先执行父类的非静成员变量初始化，然后执行父类的构造方法。
  3. 最后执行子类的非静成员变量初始化，然后执行子类的构造方法。

抽象类和接口怎么办

• 抽象类和普通类初始化顺序一样，只是多了抽象方法。

• 接口是没有构造方法，不能写代码块，只有成员方法和变量，如下：

  public interface IB {
  // 只能为public static final
  int i = 11;
  int c = 11;
  // 必须要有方法体，只能为public
  static void print() {
      System.out.println("IB print() i=" + i);
  }
  
  // 只能为public
  void test();
  }
  public class B implements IB{
  public static int b = 11;
  }

  所以接口是没有实力化引用方式的，new B()时IB中的i是不会初始化的,而且B.i被调用时也不会像继承那样引发IB中的i初始化。
  当IB.i调用是IB.c是不会被初始化的，不过如果IB.print()被调用会引发接口中的IB.i,IB.c的初始化，因为print()可以调用到i,c所以再使用前必须对i,c预先初始化。

标注：静态的变量和代码块是属于类的，只会加载一次。