java初始化

Java初始化例子, 摘自Think in Java

public class Bowl {
    
    Bowl(int marker) {  
        System.out.println("Bowl(" + marker + ")");  
    }  
  
    void f1(int marker) {  
        System.out.println("f1(" + marker + ")");  
    }  

}



public class Cupboard {
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);

    Cupboard() {
        System.out.println("Cupboard()");
        bowl4.f1(2);
    }

    void f3(int marker) {
        System.out.println("f3(" + marker + ")");
    }

    static Bowl bowl5 = new Bowl(5);

}




public class Table {
    
    static Bowl bowl1 = new Bowl(1);  
      
    Table() {  
        System.out.println("Table()");  
        bowl2.f1(1);  
    }  
  
    void f2(int marker) {  
        System.out.println("f2(" + marker + ")");  
    }  
  
    static Bowl bowl2 = new Bowl(2);  

}




/**
 * 无论创建多少对象, 静态数据都只占用一份存储区域  
 * 初始化的顺序是先静态对象(如果它们尚未因前面的对象创建过程而被初始化), 而后是"非静态"对象  
 * 载入.class文件(这将创建Class对象),有关静态初始化的所有动作执行.  
 * 静态初始化只在Class对象首次加载的时候进行一次 
 */
public class StaticInitialization {
    public static void main(String[] args) {
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        table.f2(1);
        cupboard.f3(1);
    }

    static Table table = new Table();
    static Cupboard cupboard = new Cupboard();
}

运行结果：
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)

/**
 *昆虫类 
 */
public class Insect {
    private int i =9;
    
    protected int j;
    
    Insect(){
        System.out.println("i="+i+",j="+j);
        j=39;
    }
    
    private static int x1 = printInit("static Insect.x1 initialized");
    
    static int printInit(String s){
        System.out.println(s);
        return 47;
        
    }

}


/**
 *甲壳虫类 继承昆虫类
 *初始化的顺序是先父类static对象,再子类static对象
 *然后初始化父类的全局变量，父类的构造器
 *最后初始化子类的全局变量，子类的构造器 
 */
public class Beetle extends Insect{
    private int k = printInit("Beetle.k initialized");
    
    public Beetle(){
        System.out.println("k="+k);
        System.out.println("j="+j);
    }
    
//    private static int x2 = printInit("static Beetle.x2 initialized");
    
    public static void main(String[] args) {
        System.out.println("Beetle constructor");
        Beetle b = new Beetle();
    }
    

}

运行结果：
static Insect.x1 initialized
Beetle constructor
i=9,j=0
Beetle.k initialized
k=47
j=39

总结：

1. 一个类的所有基本类型数据成员都会保证获得一个初始值，非基本类型，会初始化为null。
2. 在一个类中，无论变量的定义是在方法之前还是方法之后，都会在方法之前进行初始化的；另外，static数据初始化位于非static数据初始化之前。
3. 由于static值只有一个存储区域，所以static值只会被初始化一次。
4. 静态块里的变量初始化顺序位于普通变量之前，和static变量相比，则是完全由定义的顺序来决定了。另外，静态块里的变量也是只初始化一次，这点和static变量一致。
5. 先初始化父类的static变量或静态块再初始化子类的，其初始化顺序是从前往后，static变量初始完了后，先初始化父类全局变量，然后是子类全局变量。