构造器的初始化

可以用构造器来初始化，在运行的时候可以调用方法或者执行某些动作来确定初值。在一个类中，变量在方法和构造器之前初始化。

package com.sunyard.utils.noveber;

/**
 * 在House类中，故意将Window的定义到处散开，是要证明Window的对象定义不管在什么地方都要比House里面的方法和构造器先初始化
 * 然后再初始化House里面的构造器，w3这个引用被初始化了两次，第二次初始化过后引用就指向第二个对象，第一个对象就会被垃圾回收。
 */
public class OrderOfInitialization {
    public static void main(String[] args){
        House h=new House();
        h.f();
    }
}
class Window{
    Window(int marker){
     System.out.println("Window("+marker+")");
    }
}
class House{
    Window w1=new Window(1);//1
    House(){
        System.out.println("House()");//4
        w3=new Window(33);//5
    }
    Window w2=new Window(2);//2
    void f(){System.out.println("f()");}//6
    Window w3=new Window(3);//3
}

 

package com.sunyard.utils.noveber;

/**
 *无论创建多少对象，静态数据都只是占用了一份存储空间，在main方法执行之前,main方法所在类的静态属性要先初始化，
 * Table类和Cupboard类要先初始化，这两个类要初始化，那么他们的属性要先初始化然后再构造器初始化。另外要注意的
 * 是静态属性要比非静态的属性先初始化。
 */
class Bowl{
    Bowl(int marker){
        System.out.println("Bowl("+marker+")");
    }
    void f1(int marker){
        System.out.println("f1("+marker+")");
    }
}
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 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 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);
        cupboard1.f3(1);
    }
    static Table table=new Table();
    static Cupboard cupboard1=new Cupboard();
}

package com.sunyard.utils.noveber;
/**
 * 如果注销（2）的代码，静态快的代码会执行，非静态块的代码不会执行，Cups类中的构造器也不会执行。
 * 如果注销（1）的代码，静态快和非静态块的代码都会执行，而静态块的只会执行一次，构造器也会执行。
 * 非静态块只有Cups类新建对象的时候才执行。
 */
class Cup{
    Cup(int marker){
        System.out.println("Cup("+marker+")");
    }
    void  f(int marker){
        System.out.println("f("+marker+")");
    }
}
class Cups{
    static Cup cup1;
    Cup cup3;
    static Cup cup2;
    Cup cup4;
    {
        cup3=new Cup(3);
        cup4=new Cup(4);
    }
    static {
        cup1=new Cup(1);
        cup2=new Cup(2);
    }
    Cups(){
        System.out.println("Cups()");
    }
}
public class ExplicitStatic {
    public static void main(String[] args){
        System.out.println("Inside main");
        Cups.cup1.f(99);//(1)
    }
//    static Cups cups1=new Cups();//(2)
//    static Cups cups2=new Cups();//(2)
}

注销（2）代码的结果是：

注销（1）代码的结果：

参考：think  in java..........