给几个例子：
第一个如下：
－－－有继承存在的情况下
class A {
public A() {
System.out.println("enter A()");
init();
System.out.println("exit A()");
}
public void init() {
System.out.println("enter A.init");
System.out.println("exit A.init");
}
}
public class B extends A {
public B() {
System.out.println("enter B()");
System.out.println("exit B()");
}
int i;
int s = inits();
public static int inits() {
System.out.println("enter B.inits");
System.out.println("exit B.inits");
return 0;
}
public void init() {
System.out.println("enter B.init");
i = 100;
s = 100;
System.out.println("exit B.init");
}
public void println() {
System.out.println("enter B.println");
System.out.println(i);
System.out.println(s);
System.out.println("exit B.println");
}
public static void main(String[] arg) {
new B().println();
}
}
运行结果：
enter A()
enter B.init
exit B.init
exit A()
enter B.inits
exit B.inits
enter B()
exit B()
enter B.println
100
0
exit B.println
由此可以看出大致执行顺序如下：
main的new B()
->class B的public B()的第一行（首先调用基类构造函数，隐含的super()调用），第二行还没执行又
->class A的public A()第一行，第二行init()去调用class B的init()而不是class A的init()所以
这里i=100,s=100（运行时多态性），public A()完了之后
->public B()的第一行，下面先执行实例变量的初始化。（此处在下面继续讨论）
下来是s=inits()结果s=0，i没变还是100，最后才执行public B()的两条输出，到这里new B()才算完，
下面就是B的println()。
第二个例子：
-------int i; 和 int i = 0;的区别
class Base {
Base() {
System.out.println("Base() before print()");
print();
System.out.println("Base() after print()");
}
public void print() {
System.out.println("Base.print()");
}
}
class Derived extends Base {
int value = 100;
Derived() {
System.out.println("Derived() With " + value);
}
public void print() {
System.out.println("Derived.print() with " + value);
}
}
public class Main {
public static void main(String[] args) {
new Derived();
}
}
运行结果如下：
Base() before print()
Derived.print() with 0
Base() after print()
Derived() With 100
int i; != int i = 0;
一般的初学者都会认为两者是相同的。
但是实际上不但是在顺序上不一样，而且javac对两者的编译是完全不一样。
前者只是申明一个变量,在初始化对象变量(这里指int i = 0;)的时候并不会编译成初始化指令。
而这些初始化对象变量的指令，会在本类构造函数里面的第一条指令（注意不是构造函数之前）
之前执行，而在此之前可能已经执行了父类的构造函数。
所以我们不难推出最开始那个例子的结果为什么一个是100,一个是0。
还有要注意的是构造函数实际上并没有分配空间（尽管我们通常都会认为）。
对于一般的对象生成（用new关键字，其他情况要另外分析）。
javac会把它编译成new #number 这个指令,#number指向的是类在常数池的索引。
这个new指令就是分配对象空间，并根据类里面所声明的变量进行空间分配，
并把他们赋值成初始化的值（就是大家都知道的，int(0),objct(null)）。
举个简单的例子。对于一般的语句：比如说new A();
实际上执行顺序如下：
new #A的索引
//然后是下面大括号的指令，它们都是A的构造函数（这里的构造函数并不等同于我们代码
里面的public A() {.. }，实际上是大于,然后
根据里面的代码生成A的构造函数字节代码段。)
{
执行父类构造函数字节代码段
本类对象变量的初始化指令（比如int i = 10；这些指令是在编译时确定的）
然后下面的指令就是public A() {...}里面代码的指令
{
...
...
}
}
实际上，假如你只是在类申明了int i;而在以后的代码都不引用它的话,
javac是不会把它编译到class里面的。这也许是javac的优化结果。
第三个例子：
------一个恶心的例子
public class Singleton{
/*1）*/ private static Singleton obj = new Singleton();
/*2）*/ public static int counter1;
/*3）*/ public static int counter2 = 0;
/*4）*/ private Singleton(){
counter1++;
counter2++;
}
/*5）*/ public static Singleton getInstance(){
return obj;
}
public static void main(String[] args) {
// TODO 自动生成方法存根
Singleton obj = Singleton.getInstance();
System.out.println("obj.counter1=="+obj.counter1);
System.out.println("obj.counter2=="+obj.counter2);
}
}
执行顺序：４ ２ ３ １ ５
解释：
这个例子第一次接触是一个公司的面试题，第一次看百思不得其解。在网上搜了下，才发现。。。
如果你不知道，就看其他人写的吧。链接如下，
http://www.cnjsp.org/view.jsp?column=2&id=717
言简意赅的阐述（摘）：
当class具有static field，且直接在声明处透过「=...」的方式设定其值时，
编译器会自动将这些叙述依序搬到class constructor内。同样地，当class具有instance
field，且直接在声明处透过「=...」的方式设定其值时，编译器会自动将这些叙述依序
搬到instance constructor内。
--什么是class constructor和instance constructor?
+ class constructor是我们常用的静态块,如：
static{
}
+ instance constructor就是我们的构造方法。
so help me to get where i belong......i love u...forever....