java类中的初始化块

在类的声明中，可以包含多个初始化块，初始化块分为静态初始化块和实例初始化块，静态初始化块由static引导的用花括号括起来的语句块，它也是类的静态成员，实例初始化块没有修饰符。初始化块位于类的类体中，但不能在任何方法体内。静态初始化块只能初始化类的静态变量，实例初始化块用于初始化实例变量。

静态代码块：

定义一个类Tool：

public class Tool {

    public Tool(int i){
        System.out.println("Tool("+i+")");
    }
    public void f(int i){
        System.out.println("f("+i+")");
    }
}

将类Tools中的静态成员设为Tool的对象，创建Tools的静态初始化块，注意静态成员的定义顺序：

public class Tools {
    public static  Tool t1 = new Tool(1);
    static {
        System.out.println("进入静态初始化块");
        t1 = new Tool(11);
        t3 = new Tool(33);
        t2 = new Tool(22);
        System.out.println("退出静态初始化块");
    }
    static Tool t2 = new Tool(2);
    public Tools(){
        System.out.println("类Tools的构造方法");
    }
    static Tool t3 = new Tool(3);
}

在包含main（）方法的类中创建一个静态成员：static Tools ts = new Tools();然后执行main方法：

static Tools ts = new Tools();
public static void main(String[] args) throws CloneNotSupportedException {
    System.out.println("执行main方法");
   Tools.t1.f(4);
}

运行结果：

从结果来看，执行main方法之前，首先对静态成员static Tools ts = new Tools()初始化，这就需要加载Tools类，加载Tools类时，首先初始化Tools类的静态成员，如果静态成员没有赋值，则初始化为默认值，初始化顺序按照定义顺序执行，初始化完静态成员才会执行Tools的构造方法。在执行main方法时，由于Tools类已经被加载完了，执行Tools.t1.f(4)语句并不会再一次初始化Tools类的静态成员。所以静态初始化块只会在第一次使用其所属类时执行。

实例初始化块：

可以使用实例初始化块来初始化实例变量

public class Cat {
    public int id;
    public int age;
    {
        id  = 1;
        age  = 2;
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
     Cat cat = new Cat();
     System.out.println(cat.id+"  "+cat.age);
}

当一个类中有静态初始化块、实例初始化块和构造方法时：

public class Cat {
    public  String name;
    public int id;
    public static int age;
    static {
        System.out.println("进入静态初始化块");
        age = 1;
        System.out.println("退出静态初始化块");
    }
    {
        System.out.println("进入实例初始化块");
        id  = 1;
        name  = "a";
        System.out.println("退出实例初始化块");
    }
    public Cat(int id,String name){
        System.out.println("执行构造方法");
        this.id =id;
        this.name = name;
    }
    public Cat(){System.out.println("执行无参的构造方法");}
}

public static void main(String[] args) throws CloneNotSupportedException {
     Cat cat =new Cat();//采用无参的构造方法；
     System.out.println(cat.id+"  "+cat.name+" "+Cat.age);

}

从结果可以看出，先执行静态初始化块，初始化静态成员，再执行实例初始化块，最后调用构造方法。虽然语法上允许在实例初始化块中初始化静态变量，但一般还是在静态初始化块中初始化静态变量，因为一般情况下不会采用实例初始化块去初始化，往往通过构造方法去初始化实例变量。不过对于匿名内部类数据成员的初始化，初始化块不可或缺。

 

存在继承的情况下，代码块执行顺序：

WhiteCat类继承Cat类，Cat类继承Animal类

public class Animal {
    public static  String str = print("Animal类的静态变量初始化");
    static {
        System.out.println("进入Animal类的静态初始化块");

        System.out.println("退出Animal类静态初始化块");
    }
    {
        System.out.println("进入Animal实例初始化块");

        System.out.println("退出Animal实例初始化块");
    }
    public  static String print( String str){
        System.out.println(str);
        return str;
    }
    public Animal(){
        System.out.println("Animal类的构造器");
    }
}

public class Cat extends Animal{
    public static  String str = print("Cat类的静态变量初始化");
    static {
        System.out.println("进入Cat类的静态初始化块");

        System.out.println("退出Cat静态初始化块");
    }
    {
        System.out.println("进入Cat类实例初始化块");

        System.out.println("退出Cat实例初始化块");
    }
    public  static String print( String str){
        System.out.println(str);
        return str;
    }
    public Cat(){
        System.out.println("Cat类的构造器");

    }

}

public class WhiteCat extends Cat {
    public static  String str = print("WhiteCat类的静态变量初始化");
    static {
        System.out.println("进入WhiteCat类的静态初始化块");

        System.out.println("退出WhiteCat静态初始化块");
    }
    {
        System.out.println("进入WhiteCat类实例初始化块");

        System.out.println("退出WhiteCat实例初始化块");
    }
    public  static String print( String str){
        System.out.println(str);
        return str;
    }
   public WhiteCat(){
       System.out.println("WhiteCat类的构造器");
   }
}

public static void main(String[] args) throws CloneNotSupportedException {

         WhiteCat whiteCat = new WhiteCat();

}

从运行结果来看，首次创建子类的对象时，先加载爷爷类，对爷爷类的静态成员初始化，执行静态代码块，再加载父类，对父类的静态成员初始化，执行静态代码块，再对子类的静态成员初始化，执行子类的静态代码块，然后执行爷爷类的实例代码块，调用爷爷类的构造方法，执行父类的实例代码块，调用父类的构造方法，执行子类的实例代码块，调用子类的构造方法创建对象。

当第二次创建该子类的对象时，只会执行爷爷类的实例代码块，调用爷爷类的构造方法，执行父类的实例代码块，调用父类的构造方法，执行子类的实例代码块，调用子类的构造方法创建对象，不在执行静态成员。