关于Java构造器初始化

1、初始化顺序

package com.demo.initialization;

class Window {
    Window(int marker) {
        System.out.println("Window(" + marker + ")");
    }
}

/**
 * 变量定义初始化，会在任何方法之前
 * w1、w2、w3为变量，会在构造器之前初始化
 * @author 小小树
 */
class House {
    Window w1 = new Window(1);
    House() {
        System.out.println("House()");
        Window w3 = new Window(3);
    }
    Window w2 = new Window(2);
    void f() {
        System.out.println("f()");
    }
    Window w3 = new Window(3);
}

/**
 * 演示类内部初始化顺序
 * @author 小小树
 * 创建是时间： 2020年10月6日
 */
public class OrderOfInitialization {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        House h = new House();
        h.f();
    }

}

结果如下：

Window(1)
Window(2)
Window(3)
House()
Window(3)
f()

总结：在类的内部，变量定义的先后顺序决定了初始化的顺序，即便是构造器，也会在它之前。

 

2、静态数据的初始化

package com.demo.initialization;

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

class Table {
    static Bowl bowl = 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);
}

/**
 * 静态数据初始化
 * @author 小小树
 * @date 2020/10/6
 */
public class StaticInitialization {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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、cupboard两个静态对象，再进入main方法
     * static对象只会创建一次，没有被执行的必要则不会创建static对象 
     */
    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)

 总结：静态数据只会占用一份存储区域，static关键字不能应用于局部变量，只能作用于域。补充：注意看代码注释。

 

3、显式的静态初始化

package com.demo.initialization;

class Cup {
    Cup(int marker) {
        System.out.println("Cup("+ marker + ")");
    }
    void f(int marker) {
        System.out.println("f(" + marker + ")");
    }
}

/**
 * static语句块只会执行一次
 * @author 小小树
 * @date 2020/10/6
 */
class Cups {
    static Cup cup1;
    static Cup cup2;
    static {
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    Cups() {
        System.out.println("Cups()");
    }
}

/**
 * 显示的静态初始化
 * @author 小小树
 * @date 2020/10/6
 */
public class ExplicitStatic {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Inside main()");
        Cups.cup1.f(99);
    }
    static Cups cups1 = new Cups();
    static Cups cups2 = new Cups();
}

结果如下：

Cup(1)
Cup(2)
Cups()
Cups()
Inside main()
f(99)

 总结：static关键字后面的代码只会执行一次。

 

4、非静态实例初始化

package com.demo.initialization;
class Mug {
    Mug(int marker) {
        System.out.println("Mug(" + marker + ")");
    }
    void f(int marker) {
        System.out.println("f("+ marker +")");
    }
}

/**
 * 非静态实力初始化
 * @author 小小树
 * @date 2020/10/7
 */
public class Mugs {
    Mug mug1;
    Mug mug2;
    {
        mug1 = new Mug(1);
        mug2 = new Mug(2);
        System.out.println("mug1 & mug2 initialized");
    }
    /**
     * 测试构造器初始化是否比类成员初始化快
     */
    Mugs() {
        System.out.println("Mugs()");
    }
    public static void main(String[] args) {
        System.out.println("Insie main");
        new Mugs();
        System.out.println("new Mugs() completed");
        new Mug(1);
        System.out.println("new Mug(1) completed");
        // 再次执行Mug() 观察是否再初始化mug1、mug2
        new Mugs();
        System.out.println("new Mugs() completed");
    }
}

 结果如下：

Insie main
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs()
new Mugs() completed
Mug(1)
new Mug(1) completed
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs()
new Mugs() completed