分析一下代码初始化过程，为什么会出现以下打印结果？
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);//(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);
  cupboard.f3(1);
  
}
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和非static的初始化过程。
我的分析是：首先加载StaticInitialization类，执行main()方法。main方法中有static成员，先初始化static的table和cupboard，这将导致它们对应的类也被加载，先加载Table类，类中静态成员先初始化，然后构造函数初始化。结果为Bowl(1)、Bowl(2)、Table()、f1(1)。然后加载Cupboard类，同样先静态对象初始化，然后非静态对象初始化，最后构造函数初始化，结果为Bowl(4)、Bowl(5)、Bowl(3)、Cupboard()、f1(2)。main()函数中静态成员初始化完成后，其他部分按顺序执行，出现相应结果（如上）。
值得注意的是：static成员只初始化一次，之后不会再被初始化。而非静态成员会被重复初始化。

初始化一个对象时是按这样的顺序进行的：
1、所有数据域被初始化为默认值(0, false, null)
2、按照在类声明中出现的顺序依次执行所有的域初始语句或初始化块，静态域的初始化要早于实例域的初始化
3、如果构造器第一行调用了第二个构造器，则执行第二个构造器，以此类推
4、执行这个构造器的主体

具体看下面的注释：

1. class Bowl{
   
2.         Bowl(int marker){
   
3.                 System.out.println("Bowl(" + marker + ")");
   
4.         }
   
5. 
   
6.         void f1(int marker){
   
7.                 System.out.println("f1(" + marker + ")");
   
8.         }
   
9. }
   
10. 
    
11. 
    
12. 
    
13. class Table{
    
14.         static Bowl bowl1 = new Bowl(1); //按照声明顺序 bowl1的初始化早于bowl2的初始化，然后才是Table()构造函数
    
15.         Table(){
    
16.                 System.out.println("Table()");
    
17.                 bowl2.f1(1);
    
18.         }
    
19. 
    
20.         void f2(int marker){
    
21.                 System.out.println("f2(" + marker + ")");
    
22.         }
    
23. 
    
24.         static Bowl bowl2 = new Bowl(2);//(2)
    
25. }
    
26. 
    
27. 
    
28. class Cupboard{
    
29.         Bowl bowl3 = new Bowl(3);//静态域的初始化要早于实例域并且按照声明顺序，
    
30.                                  //那么先初始化bowl4再初始化bowl5，再初始化bowl3，接着才是构造方法
    
31.         static Bowl bowl4 = new Bowl(4);
    
32. 
    
33.         Cupboard(){
    
34.                 System.out.println("Cupboard()");
    
35.                 bowl4.f1(2);
    
36.         }
    
37. 
    
38.         void f3(int marker){
    
39.                 System.out.println("f3(" + marker + ")");
    
40.         }
    
41. 
    
42.         static Bowl bowl5 = new Bowl(5);
    
43. }
    
44. 
    
45. 
    
46. public class StaticInitialization {
    
47. 
    
48.         public static void main(String[] args) {
    
49.                 System.out.println("Creating new Cupboard() in main");
    
50.   
    
51.                 new Cupboard();
    
52.   
    
53.                 System.out.println("Creating new Cupboard() in main");
    
54.                 new Cupboard();
    
55.   
    
56.                 table.f2(1);
    
57.                 cupboard.f3(1);
    
58.   
    
59.         }
    
60.         static Table table = new Table();
    
61.         static Cupboard cupboard = new Cupboard();
    
62. }

复制代码

其实你只要掌握了一条主线一切都是浮云。
for instance：
A a = new A();
假如a是一个自定义类，这句话后台要做很多事情的。首先会检查该类有没有初始化代码块，有的话先执行。然后去执行构造函数，若是该类继承了其他类，首先会去执行父类的构造函数，执行完毕后才执行自己的构造函数，以此类推，若父类还有父类。。。

先初始化父类的静态代码--->初始化子类的静态代码--> (创建实例时,如果不创建实例,则后面的不执行)初始化父类的非静态代码--->初始化父类构造函数--->初始化子类非静态代码--->初始化子类构造函数
http://bbs.itheima.com/forum.php ... %3D78%26typeid%3D78

static      非static   

静态变量是在创建类的时候就在内存中被创建了，static也叫类变量，非static 成员变量，初始化后才会开辟内存空间