1. 变量初始化

在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，

那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。

例子：

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.静态数据的初始化

若数据是静态的（static），那么同样的事情就会发生；如果它属于一个基本类型（主类型），而且未对其初始化，就会自动获得自己的标准基本类型初始值；如果它是指向一个对象的句柄，那么除非新建一个对象，并将句柄同它连接起来，否则就会得到一个空值（NULL）。

例子：

class Bowl 
{
  Bowl(int marker) {
    System.out.println("Bowl(" + marker + ")");
  }
  void f(int marker) {
    System.out.println("f(" + marker + ")");
  }
}
class Table
 {
  static Bowl b1 = new Bowl(1);
  Table() {
    System.out.println("Table()");
    b2.f(1);
  }
  void f2(int marker) {
    System.out.println("f2(" + marker + ")");
  }
  static Bowl b2 = new Bowl(2);
}
class Cupboard 
{
  Bowl b3 = new Bowl(3);
  static Bowl b4 = new Bowl(4);
  Cupboard() {
    System.out.println("Cupboard()");
    b4.f(2);
  }
  void f3(int marker) {
    System.out.println("f3(" + marker + ")");
  }
  static Bowl b5 = 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();
    t2.f2(1);
    t3.f3(1);
  }
  static Table t2 = new Table();
  static Cupboard t3 = new Cupboard();
}

结果：

Bowl(1)

Bowl(2)

Table()

f(1)

Bowl(4)

Bowl(5)

Bowl(3)

Cupboard()

f(2)

Creating new Cupboard() in main

Bowl(3)

Cupboard()

f(2)

Creating new Cupboard() in main

Bowl(3)

Cupboard()

f(2)

f2(1)

f3(1)

static初始化只有在必要的时候才会进行。如果不创建一个 Table 对象，而且永远都不引用Table.b1 或Table.b2，那么 static Bowl b1 和b2 永远都不会创建。然而，只有在创建了第一个Table 对象之后（或者发生了第一次static 访问），它们才会创建。在那以后，static 对象不会重新初始化。Static仅执行一次——首次生成那个类的一个对象时，或者首次访问属于那个类的一个 static 成员时。（即便从未生成过那个类的对象）。

初始化的顺序是首先static（如果它们尚未由前一次对象创建过程初始化），接着是非static 对象。

在这里有必要总结一下对象的创建过程。请考虑一个名为 Dog的类：

(1) 类型为 Dog的一个对象首次创建时，或者Dog 类的static方法／static 字段首次访问时，

   Java 解释器必须找到Dog.class（在事先设好的类路径里搜索）。

(2) 找到Dog.class 后（它会创建一个 Class对象，这将在后面学到），它的所有 static初始

   化模块都会运行。因此，static初始化仅发生一次——在 Class 对象首次载入的时候。

(3) 创建一个new Dog()时，Dog 对象的构建进程首先会在内存堆（Heap）里为一个 Dog对 

   象分配足够多的存储空间。

(4) 这种存储空间会清为零，将Dog中的所有基本类型设为它们的默认值（零用于数字，以 

   及 boolean和char 的等价设定）。

(5) 进行字段定义时发生的所有初始化都会执行。

(6) 执行构建器。正如第6 章将要讲到的那样，这实际可能要求进行相当多的操作，特别是

   在涉及继承的时候。

3. 明确进行的静态初始化（静态块）

Java 允许我们将其他static初始化工作划分到类内一个特殊的“static 构建从句”（有时也叫作“静态块”）里。

尽管看起来象个方法，但它实际只是一个static 关键字，后面跟随一个方法主体。与其他 static初始化一样，这段代码仅执行一次——首次生成那个类的一个对象时，或者首次访问属于那个类的一个 static 成员时（即便从未生成过那个类的对象）。

例子：

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()");
  }
}
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)
}

在标记为(1)的行内访问 static 对象c1 的时候，或在行(1)标记为注释，同时(2)行不标记成注释的时候，用于Cups 的 static初始化模块就会运行。若(1)和(2)都被标记成注释，则用于 Cups 的static 初始化进程永远不会发生。

4. 非静态实例的初始化（非静态块）

针对每个对象的非静态变量的初始化，Java 1.1 提供了一种类似的语法格式。

例子：

class Mug
{
  Mug(int marker) {
    System.out.println("Mug(" + marker + ")");
  }
  void f(int marker) {
    System.out.println("f(" + 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();
  }
}

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