飞的更高

给几个例子：

第一个如下：

－－－有继承存在的情况下

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就是我们的构造方法。