類的繼承機制使得子類可以使用父類的功能（即代碼），並且子類也具有父類的類型。下面介紹類在繼承關系上的初始化的順序問題。
示例1：
class SuperClass
{
SuperClass()
{
System.out.println("SuperClass constructor");
}
}
public class SubClass extends SuperClass
{
SubClass()
{
System.out.println("SubClass constructor");
}
public static void main(String[] args)
{
SubClass sub = new SubClass();
}
}
輸出結果： SuperClass
constructor
SubClass constructor
在子類中只實例化了一個子類對象。從輸出結果上看，程序並不是一開始就運行自己的構造方法，而是先運行其父類的默認構造方法。注意：程序自動調用其父類的默認構造方法。
示例2：
class SuperClass
{
SuperClass(String str)
{
System.out.println("Super with a string.");
}
}
public class SubClass extends SuperClass
{
SubClass(String str)
{
System.out.println("Sub with a string.");
}
public static void main(String[] args)
{
SubClass sub = new SubClass("sub");
}
}
在JDK下編譯此程序不能成功。正如上例中說的：程序在初始化子類時先要尋找其父類的默認構造方法，結果沒找到，那麼編譯自然不能通過。
解決這個問題有兩個辦法：
1．在父類中增加一個默認構造方法。
2．在子類的構造方法中增加一條語句：super(str); 且必須在第一句。
這兩種方法都能使此程序通過編譯，但就本程序來說運行結果卻不相同。
第1種方法的運行結果是：
Sub with a string.
第2種方法的運行結果是：
Super with a string.
Sub with a string.
第2種解決方法實際上是指定編譯器不要尋找父類的默認構造方法，而是去尋找帶一個字符串為參數的構造方法。
下面介紹對象的初始化順序問題。
示例3：
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start...");
Two two = new Two("two");
}
}
輸出結果：
Test main() start...
one-1
one-2
one-3
two
在main()方法中實例化了一個Two類的對象。但程序在初始化Two類的對象時，並非先調用Two類的構造方法，而是先初始化Two類的成員變量。這裡Two類有3個成員變量，它們都是One類的對象，所以要先調用3次One類的相應的構造方法。最後在初始化Two類的對象。
示例4：
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start...");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}
輸出結果：
Test main() start...
one-3
one-1
one-2
two-1
------------
one-1
one-2
two-2
如果一個類中有靜態對象，那麼它會在非靜態對象前初始化，但只初始化一次。非靜態對象每次調用時都要初始化。
示例5：
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
3
}
public class Test
{
static Two two_3 = new Two("two-3");
public static void main(String[] args)
{
System.out.println("Test main() start...");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}
輸出結果：
one-3
one-1
one-2
two-3
Test main() start...
one-1
one-2
two-1
------------
one-1
one-2
two-2
程序中主類的靜態變量會在main()方法執行前初始化。結果中只輸出了一次one-3，這也說明：如果一個類中有靜態對象，那麼它會在非靜態對象前初始化，但只初始化一次。非靜態對象每次調用時都要初始化。
示例6：
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
static int i = 0;
One one_1 = new One("one-1");
static One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start...");
System.out.println("Two.i = " + Two.i);
}
}
4
輸出結果：
Test main() start...
one-2
one-3
Two.i = 0
不僅第1次創建對象時，類中所有的靜態變量要初始化，第1次訪問類中的靜態變量（沒有創建對象）時，該類中所有的靜態變量也要按照它們在類中排列的順序初始化。
綜上所述：
在創建對象時，對象所在類的所有數據成員會首先進行初始化，如果其中的成員變量有對象，那麼它們也會按照順序執行初始化工作。在所有類成員初始化完成後，才調用對象所在類的構造方法創建對象。構造方法作用就是初始化。
靜態對象（變量）在非靜態對象前初始化。靜態對象（變量）只初始化一次，再次調用就不初始化了，但非靜態對象在每次調用時都要初始化。
程序中的主類的靜態變量會在main()方法執行前進行初始化工作。
不僅第1次創建對象時，類中所有的靜態變量要初始化，第1次訪問類中的靜態變量（沒有創建對象）時，該類中所有的靜態變量也要按照它們在類中排列的順序初始化。
初始化的順序包括構造方法調用的順序如下：
1．主類的靜態成員首先初始化。
2．主類的超類的構造方法按照從最高到最低的順序被調用。
3．主類的非靜態對象（變量）初始化。
4．調用主類的構造方法。
在一個構造方法中只能調用一次其它的構造方法，並且調用構造方法的語句必須是第一條語句。
