先上例子：

1 public class Bowl {
    2  3     public Bowl(int marker){
    4         System.err.println("Bowl:" + marker);  5     }  6      7     public void BowlFun(int marker){
    8         System.err.println("BowlFun(" + marker + ")");  9     } 10 }

public class Table {
   public static Bowl b1 = new Bowl(1); public Table() {
           System.err.println("Table()");         b2.BowlFun(1);     } public void TableFun(int marker) {
           System.err.println("TableFun(" + marker + ")");     } public static Bowl b2 = new Bowl(2); }

1 public class Cupboard {
    2  3     Bowl b3 = new Bowl(3);  4     static Bowl b4 = new Bowl(4);  5      6     public Cupboard() {
    7         System.err.println("Cupboard()");  8         b4.BowlFun(2);  9     } 10     11     public void CupboardFun(int marker) {
   12         System.err.println("CupboardFun(" + marker + ")"); 13     } 14     15     static Bowl b5 = new Bowl(5); 16 }

1 public class RoadBoot {
    2      3     public static void main(String args[]){
    4  5         System.err.println("Create new Cupboard in main()");  6          7         Cupboard cc = new Cupboard();  8          9         System.err.println("Create new Cupboard in main()"); 10         11         cc = new Cupboard(); 12         13         table.TableFun(1); 14         cboard.CupboardFun(1); 15     } 16     17     static Table table = new Table(); 18     static Cupboard cboard = new Cupboard(); 19 }

输出结果是：

Bowl:1

Bowl:2

Table()

BowlFun(1)

Bowl:4

Bowl:5

Bowl:3

Cupboard()

BowlFun(2)

Create new Cupboard in main()

Bowl:3

Cupboard()

BowlFun(2)

Create new Cupboard in main()

Bowl:3

Cupboard()

BowlFun(2)

TableFun(1)

CupboardFun(1)

说明：

1：static成员的初始化只有在需要的时候才会进行（创建包含static成员的类对象，或直接通过类名称引用它内部的static成员）。

2：初始化的顺序是先static对象，再非static对象。

 

首先看类RoadBoot，包含两个static对象，这两个对象会在main调用之前就被初始化，按顺序来，先初始化table，再初始化cboard。

Table类的内容如下：

1 public class Table {
    2  3     public static Bowl b1 = new Bowl(1);  4      5     public Table() {
    6         System.err.println("Table()");  7         b2.BowlFun(1);  8     }  9     10     public void TableFun(int marker) {
   11         System.err.println("TableFun(" + marker + ")"); 12     } 13     14     public static Bowl b2 = new Bowl(2); 15 }

在调用其构造函数之前，会先对其包含的成员变量进行初始化，首先进行static的初始化，按顺序来，b1，会打印出Bowl1；接下来是b2，会打印出Bowl2。

除此之外，该类不包含非static成员，所以要进行构造函数的调用了，则会先打印出Table()，再调用b2.BowlFun(1)打印出BowlFun(1)，Table类完成。

接下来看Cupboard类：

1 public class Cupboard {
    2  3     Bowl b3 = new Bowl(3);  4     static Bowl b4 = new Bowl(4);  5      6     public Cupboard() {
    7         System.err.println("Cupboard()");  8         b4.BowlFun(2);  9     } 10     11     public void CupboardFun(int marker) {
   12         System.err.println("CupboardFun(" + marker + ")"); 13     } 14     15     static Bowl b5 = new Bowl(5); 16 }

先进行static成员的初始化b4，会打印出Bowl4，接下来是b5，会打印出Bowl5，没有其它static成员了，再进行非static成员的初始化，b3，打印出

Bowl3，初始化完这个之后，也没有其它的非static成员了，可以进行构造函数的调用了，打印出Cupboard()和BowlFun2

此时，可以进行main函数的调用了：

1     public static void main(String args[]){
    2  3         System.err.println("Create new Cupboard in main()");  4          5         Cupboard cc = new Cupboard();  6          7         System.err.println("Create new Cupboard in main()");  8          9         cc = new Cupboard(); 10         11         table.TableFun(1); 12         cboard.CupboardFun(1); 13     }

先打印出Create new Cupboard in main()，接着创建Cupboard对象，在该类中，由于静态成员b4和b5已初始化，故不会重复初始化，而只有非static成员b3，

会再次被初始化，打印出Bowl3，接来进再调用构造函数，从而打印出Cupboard()，BowlFun(2)；第7，9行的输出与第3，5行的输出完全相同。

最后，分别执行table.TableFun(1);cboard.CupboardFun(1);打印出TableFun(1)，CupboardFun(1)

再次重申：

1：static成员的初始化只有在需要的时候才会进行（创建包含static成员的类对象，或直接通过类名称引用它内部的static成员）。

2：初始化的顺序是先static对象，再非static对象。