（三）《Java编程思想》——构造函数初始化

1.初始化顺序是由变量在类内的定义顺序决定的，并且先初始化变量，然后才调用构造函数。

package chapter4;

//: OrderOfInitialization.java
/**
 * 初始化顺序
 */
class Tag {
    Tag(int marker) {
        System.out.println("Tag(" + marker + ")");
    }
}

class Card {
    Tag t1 = new Tag(1); // Before constructor

    Card() {
        // Indicate we're in the constructor:
        System.out.println("Card()");
        t3 = new Tag(33); // Re-initialize t3
    }

    Tag t2 = new Tag(2); // After constructor

    void f() {
        System.out.println("f()");
    }

    Tag t3 = new Tag(3); // At end
}

public class OrderOfInitialization {
    public static void main(String[] args) {
        Card t = new Card();
        t.f(); // Shows that construction is done
    }

} // /:~

【运行结果】：

Tag(1)
Tag(2)
Tag(3)
Card()
Tag(33)
f()

2. 静态数据的初始化

先来看看main函数所在类。main是程序的入口，调用一切对象必须先实例化。

package chapter4;
public class StaticInitialization {
    public static void main(String[] args) {
        StaticInitialization s = new StaticInitialization();
        System.out.println("i="+s.i);
    }
    int i;
}

【运行结果】：i=0

如果变量为静态，将在main函数之前初始化。

package chapter4;
public class StaticInitialization1 {
    public static void main(String[] args) {
        System.out.println("i="+i);
    }

    static int i=5;
}

【运行结果】：i=5

实例化类将默认调用构造函数

package chapter4;
class Table {
    Table() {
        System.out.println("Table()");
    }
}

public class StaticInitialization1 {
    public static void main(String[] args) {
        Table t2 = new Table();

    }
}

【运行结果】：Table()

如果变量为静态，将在main函数之前初始化。同样适用于类（类是一种自定义变量）

package chapter4;
class Table {
    Table() {
        System.out.println("Table()");
    }
}

public class StaticInitialization1 {
    public static void main(String[] args) {

    }

    static Table t2 = new Table();
}

【运行结果】：Table()

类内变量、静态变量初始化及构造函数调用顺序：

静态变量、变量、构造函数

package chapter4;

class Bowl {
    Bowl(int marker) {
        System.out.println("Bowl(" + marker + ")");
    }
}
class Table {
    Bowl b1 = new Bowl(1);

    Table() {
        System.out.println("Table()");
    }

    static Bowl b2 = new Bowl(2);
}

public class StaticInitialization1 {
    public static void main(String[] args) {

    }

    static Table t2 = new Table();
}

【运行结果】：

Bowl(2)
Bowl(1)
Table()

static 初始化仅发生一次

package chapter4;

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

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

class Table {
    Bowl b1 = new Bowl(1);

    Table() {
        System.out.println("Table()");
    }

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

    static Bowl b2 = new Bowl(2);
}

public class StaticInitialization1 {
    public static void main(String[] args) {
        System.out.println("=========main===========");
        Table t3 = new Table();
        t2.f2(2);
    }

    static Table t2 = new Table();
}

【运行结果】：

Bowl(2)
Bowl(1)
Table()
=========main===========
Bowl(1)
Table()
f2(2)

静态块:仅执行一次——首次生成那个类的一个对象时，或者首次访问属于那个类的一个static 成员时

//: ExplicitStatic.java
// Explicit static initialization
// with the "static" clause.
class Cup {
Cup(int marker) {
System.out.println("Cup(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}
class Cups {
static Cup c1;
static Cup c2;
static {
c1 = new Cup(1);
c2 = new Cup(2);
}
Cups() {
System.out.println("Cups()");
115
}
}
public class ExplicitStatic {
public static void main(String[] args) {
System.out.println("Inside main()");
Cups.c1.f(99); // (1)
}
static Cups x = new Cups(); // (2)
static Cups y = new Cups(); // (2)
} ///:~

【运行结果】：

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

非静态实例的初始化可定义成与静态块类似的形式：

package chapter4;

//: Mugs.java
// Java 1.1 "Instance Initialization"
class Mug {
    Mug(int marker) {
        System.out.println("Mug(" + marker + ")");
    }
}

public class Mugs {
    Mug c1;
    Mug c2;
    {
        c1 = new Mug(1);
        c2 = new Mug(2);
        System.out.println("c1 & c2 initialized");
    }

    Mugs() {
        System.out.println("Mugs()");
    }

    public static void main(String[] args) {
        System.out.println("Inside main()");
        Mugs x = new Mugs();
    }
} // /:~

【运行结果】：

Inside main()
Mug(1)
Mug(2)
c1 & c2 initialized
Mugs()

这段定义代码

{
        c1 = new Mug(1);
        c2 = new Mug(2);
        System.out.println("c1 & c2 initialized");
    }

看起来与静态初始化从句极其相似，只是static 关键字从里面消失了。为支持对“匿名内部类”的初始化必须采用这一语法格式。