《Thinking in Java》（京京工作室 译） page 93 
4.4.2 构建器初始化

//:OrderOfInitialization.java
//Demostrates initialization order.

//When the constructor is called, to create a
//Tag object, you'll see a message:

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

class Card {
  Tag t12 = 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()

谁能解释一下这个程序，并把它的执行顺序及为什么会这样执行讲一下。兄弟Java初学，不明白的地方很多，还望能讲清楚些，一定多多送分！！！

在你执行OrderOfInitialization 类时，首先找到这个类的入口函数main---》Card t = new Card();将首先初始化card里面的成员变量，他的成员变量为：Tag t12 = new Tag(1);  Tag t2 = new Tag(2); Tag t3 = new Tag(3);
然后调用card类的构造函数。然后输出了Card()；有因为构造函数调用了t3 = new Tag(33); 所以输出Tag(33）。

然后这个  Card t = new Card();执行完成，执行下一语句：
t.f();
所以输出了f().
其实最难了解的就是前3个，因为他门是类的成员变量所以没有调用构造函数 前就先初始化。

首先执行card方法中的new程序，
然后在执行构建器，最后调用f()方法。
还有什么不懂的？
这是java所规定的呀。

OrderOfInitialization的main是入口，new Card()会使虚拟机创建一个Card对象，创建Card对象时，虚拟机会先将这个对象需要的变量准备好，于是就按顺序输出了Tag1，2，3,这个顺序基本上依赖于程序的顺序和变量的调用关系，在所有的基础设置准备完毕后，Card的构建方法才会被执行，于是输出Card()，在输出Card()这个字符串后又创建了Tag33，接下来，入口main方法又调用了Card对象的f()方法，所以最后输出的是f()。

就是在java中、用new、生成一个新对象、初始化的顺序是:
1。在类中定义的变量
2。执行构造函数

用new 生成对象时候，初始化顺序：
1.static类型的class级别变量
2.非static类型的class级别变量
3.构造函数

如同一级别的变量有多个，按在source code 中出现的顺序初始化。

wjmmml(笑着悲伤) 
真的很感谢你
虽然我不是这个帖的主人
但是
我觉得仍然有必要向你谢谢

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

class Card {
int card;

Tag t12 = new Tag(1);  //Before constructor
  Card () {
    // Indicate we're in the constructor:
    System.out.println("Card.card=="+card);
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 {
   static int first=first();
   public static int first()
{
   System.out.println("I am the first !!");
   return 123;
}
   public static void main(String[] args) {
     System.out.println("in the main");
 Card t = new Card();
     t.f(); //Shows that construction is done
   }
}///:~

/* 
   运行一下这个程序，就发现main()不是入口！！
   可见一个类的 main 方法未必是第一个执行的，所以不一定是入口！
   java OrderOfInitialization == 
         (new OrderOfInitialization()).main();
   这是我的感觉，我也不知道JVM是怎么工作的~~
   就是说你在用 java OrderOfInitialization 的时候，JVM 先 new 一个 类OrderOfInitialization的对象，这个对象的初始化顺序也是按照下面这个顺序来进行的。
   一个类的初始化及执行顺序： static 变量---〉static 函数（被前面的static变量调用的时候才执行，当然也包括main，因为main也是static方法）-->非static变量的自动初始化（先自动初始化为默认值，比如int的先赋值0，再在构造方法里面修改--〉构造方法 
  以上是一家之言，但这样理解和JVM的实现是一样的，欢迎大家讨论
  当然 用 static方法给 static 变量赋值有点变态，Deprecated!!!
*/