Object class And Extneds

作者 : 許裕永

繼承（Ｉｎｈｅｒｉｔａｎｃｅ）是物件導向的重要特性，就是撰寫類別時，替類別指定一個上層類別。則下層類別（ｓｕｂ　ｃｌａｓｓ）便繼承了上層類別 （ｓｕｐｅｒ　ｃｌａｓｓ）中的所有成員（不包含建構方法）。也就是說：「下層類別不必再重複撰寫上層類別中，已經撰寫過的程式碼，只要撰寫屬於自己的程 式碼」。也可以說：「下層類別擴充了上層類別的功能」。
實務上，我們把大部份類別，都需要的資料成員及方法成員，撰寫成一個上層類別。那麼在撰寫其他類別時，只要繼承此上層類別，則各下層類別之中，便可以省略 在上層類別中，已經宣告過的資料成員及方法成員。而可以把宣告在上層類別中的成員，當作是下層類別中自己宣告的成員來存取。如此在開發大型專案時，只要規 劃得當，這樣一層一層的繼承機制，省下的時間，就非常可觀了。
換個角度來看，上層類別中宣告的成員，下層類別可以繼承，也可以看成上層類別中宣告了下層類別一定要有的成員，想要沒有都不行。也就是說：上層類別中宣告了下層類別一定要擁有的資料成員及方法成員。
實務上，我們把對大部份類別的限制，撰寫在上層類別之中，可以限定下層類別開發時，一定會符合上層類別的規範，如此可以減少日後大型專案整合時的邏輯錯誤。
下層類別繼承了上層類別中的那些成員？答案是：「除了建構方法之外的所有成員，只是並非所有成員都可以任意存取」。上層類別中宣告為ｐｒｉｖａｔｅ的成 員，下層類別有繼承，但是不能存取。上層類別中宣告為ｐｒｏｔｅｃｔｅｄ的成員，不同ｐａｃｋａｇｅ的下層類別，可以在類別中以直接存取的方式存取，但是 不能建構成物件之後以物件存取，同一個ｐａｃｋａｇｅ的下層類別可以用任意方式存取。上層類別中宣告為ｐｕｂｌｉｃ的成員，下層類別中可以用任意方式存 取。上層類別中未宣告存取限制的成員，同一個ｐａｃｋａｇｅ的下層類別可以用任意方式存取，不同ｐａｃｋａｇｅ的下層類別中，不可以存取。
為了規範所有Ｊａｖａ的類別，必需具備的功能及規格，Ｊａｖａ提供了一個類別：Ｏｂｊｅｃｔ。它是Ｊａｖａ所有類別的共同上層類別。即使我們開發的新類別 沒有宣告繼承，Ｊａｖａ也會讓此新類別繼承Ｏｂｊｅｃｔ。也就是說：只要是Ｊａｖａ的類別，就一定擁有Ｏｂｊｅｃｔ中宣告的成員。
　

1. Ｏｂｊｅｃｔ
ｊａｖａ‧ｌａｎｇ‧Ｏｂｊｅｃｔ是Ｊａｖａ所有類別的上層類別，也就是任何Ｊａｖａ的類別都一定擁有Ｏｂｊｅｃｔ中宣告的成員方法。
１－１　重要方法
方法一：ｐｒｏｔｅｃｔｅｄ　　Ｏｂｊｅｃｔ　ｃｌｏｎｅ（）　
複製執行本方法的物件。
　
方法二：ｂｏｏｌｅａｎ　ｅｑｕａｌｓ（Ｏｂｊｅｃｔ　ｏｂｊ）　
參數物件與本物件是否為同一個物件。
　
方法三：ｐｒｏｔｅｃｔｅｄ　　ｖｏｉｄ　ｆｉｎａｌｉｚｅ（）　
本物件被消毀時，Ｊａｖａ會呼叫的方法。
　
方法四：ｉｎｔ　ｈａｓｈＣｏｄｅ（）　
本物件的雜湊碼。
　
方法五：ｖｏｉｄ　ｎｏｔｉｆｙ（）　
通知物件離開等待狀態（執行緒同步化時使用）。
　
方法六：ｖｏｉｄ　ｎｏｔｉｆｙＡｌｌ（）　
通知所有本類別物件離開等待狀態（執行緒同步化時使用）。
　
方法七：Ｓｔｒｉｎｇ　ｔｏＳｔｒｉｎｇ（）　
描述本物件的文字。
　
方法八：ｖｏｉｄ　ｗａｉｔ（）　
方法九：ｖｏｉｄ　ｗａｉｔ（ｌｏｎｇ　ｔｉｍｅｏｕｔ）　
方法十：ｖｏｉｄ　ｗａｉｔ（ｌｏｎｇ　ｔｉｍｅｏｕｔ，　ｉｎｔ　ｎａｎｏｓ）
讓物件進入等待狀況（執行緒同步化時使用）。
　
以上方法，有些會在本章後續節次中介紹，有些會在本書後續章節中介紹，讀者只要先有概念即可。
　
2. ｅｘｔｅｎｄｓ
語法：ｃｌａｓｓ　ＣｌａｓｓＮａｍｅ　ｅｘｔｅｎｄｓ　ＳｕｐｅｒＣｌａｓｓＮａｍｅ｛｝
ＳｕｐｅｒＣｌａｓｓＮａｍｅ：上層類別名稱。每個類別只能有一個上層類別，若沒有宣告上層類別，則此類別的上層類別預設為Ｏｂｊｅｃｔ。
　
例一：
public class SubClass{
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　System.out.println(sc.hashCode());
　　System.out.println(sc.toString());
　}
}
列印結果：3526198　SubClass@35ce36。
示範主題：上層類別宣告為ｐｕｂｌｉｃ的成員，也就是下層類別ｐｕｂｌｉｃ的成員，可以用物件存取。
　
例二：
public class SubClass{
　public int myHashCode(){
　　return hashCode()*5;
　}
　public String myToString(){
　　return "Yung " + toString();
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　System.out.println(sc.myHashCode());
　　System.out.println(sc.myToString());
　}
}
列印結果：17630990　Yung SubClass@35ce36。
示範主題：上層類別宣告的成員（非ｐｒｉｖａｔｅ），可以在下層類別中直接存取（呼叫）。
　
例三：
class SuperClass{}
public class SubClass extends SuperClass{
　public int myHashCode(){
　　return hashCode()*5;
　}
　public String myToString(){
　　return "Yung " + toString();
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　System.out.println(sc.myHashCode());
　　System.out.println(sc.myToString());
　}
}
列印結果：17630990　Yung SubClass@35ce36。
示範主題：１、用ｅｘｔｅｎｄｓ指定上層類別。２、Ｏｂｊｅｃｔ是ＳｕｐｅｒＣｌａｓｓ的上層類別，它的方法被ＳｕｐｅｒＣｌａｓｓ繼承後，會再被ＳｕｂＣｌａｓｓ繼承，這是所謂「多層繼承」。
　
請注意本例可以撰寫於同一個程式碼檔，但ＳｕｐｅｒＣｌａｓｓ不可以宣告為ｐｕｂｌｉｃ，而且檔案名稱一定是ＳｕｂＣｌａｓｓ‧ｊａｖａ。
Ｏｂｊｅｃｔ是ＳｕｐｅｒＣｌａｓｓ的上層類別，也是ＳｕｂＣｌａｓｓ的上層類別（Ｊａｖａ中沒有祖類別這個名詞）。所以才會說Ｏｂｊｅｃｔ是Ｊａｖａ中所有類別的上層類別。
　
3. ｏｖｅｒｒｉｄｉｎｇ
在下層類別中重新定義上層類別中宣告的實體方法成員，稱之為「ｏｖｅｒｒｉｄｉｎｇ」。
　
３－１　限制與注意事項
我們可以先想想看，Ｊａｖａ為什麼要把Ｏｂｊｅｃｔ設為所有類別的上層類別？以類別開發者的角度來看，它限制了所有類別一定要擁有Ｏｂｊｅｃｔ中的方法成 員；但以類別使用者的角度來看，任何類別所建構的物件都可以呼叫那些Ｏｂｊｅｃｔ中宣告的方法，來執行特定功能，或取得指定的資料。
當我們面對一個陌生的類別時，了解這個類別最直接的方式，就是建構這個類別的物件後，呼叫這個物件的ｔｏＳｔｒｉｎｇ（）。這個物件一定有ｔｏＳｔｒｉｎｇ（）嗎？一定有，因為ｔｏＳｔｒｉｎｇ（）是Ｏｂｊｅｃｔ繼承下來的。
Ｄａｔｅ　ｄ＝ｎｅｗ　Ｄａｔｅ（）；
Ｓｙｓｔｅｍ‧ｏｕｔ‧ｐｒｉｎｔｌｎ（ｄ）；
還記得這兩行程式碼嗎？把ｄ物件列印出來，物件怎麼列印？在ｐｒｉｎｔｌｎ中的參數，表示是要列印在螢幕中的文字，所以Ｊａｖａ會自動呼叫ｄ物件的 ｔｏＳｔｒｉｎｇ（）。由此可見，ｔｏＳｔｒｉｎｇ（）是Ｊａｖａ定義在Ｏｂｊｅｃｔ中，讓所有類別建構的物件，都可以用來顯示代表該物件的文字的方法成 員。任意物件，只要是在需要轉換為字串的運算式之中，Ｊａｖａ都會自動呼叫該件的ｔｏＳｔｒｉｎｇ（）。
可是，要代表不同物件的文字不是不一樣嗎？怎麼可能定義在Ｏｂｊｅｃｔ中的一個方法就可以讓任意Ｏｂｊｅｃｔ的下層類別建構的物件，能各自顯示不同的資訊呢？之前我們做的範例，呼叫ｔｏＳｔｒｉｎｇ（）只是顯示它的物件代號，並沒有顯示什麼資訊啊？
這就是ｏｖｅｒｒｉｄｉｎｇ的必要性。每個類別，可以把從上層類別繼承過來的成員，重新定義。在Ｏｂｊｅｃｔ中宣告的方法，它們定義的內容都是基礎功能， 基本上和我們開發的類別幾乎是沒什麼關係。但它至少讓本類別擁有了這些方法，讓我們可以在類別中自行ｏｖｅｒｒｉｄｉｎｇ有必要重新定義的方法；讓本類別 建構的物件，呼叫這個方法的時候，執行的是本類別中自行定義的內容。
　
例一：
public class SubClass{
　int a;
　int b;
　public String toString(){
　　return "a=" + a + ";b=" + b;
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　System.out.println(sc.toString());
　}
}
列印結果：a=0;b=0。
示範主題：物件執行的是本類別中重新定義的內容。
ｏｖｅｒｒｉｄｉｎｇ和ｏｖｅｒｌｏａｄｉｎｇ是完全不一樣的。ｏｖｅｒｌｏａｄｉｎｇ機制下，各個方法的名稱一樣，但參數列卻一定不一樣。 ｏｖｅｒｌｏａｄｉｎｇ機制下的方法，每一個都是獨立的方法，沒有取代的問題，它們是同時存在，然後依照呼叫敍述句的參數，來執行相對應的方法。而且 ｏｖｅｒｌｏａｄｉｎｇ可以運用在開發的類別本身，也可以在下層類別中ｏｖｅｒｌｏａｄｉｎｇ上層類別的方法。
但是ｏｖｅｒｒｉｄｉｎｇ是有取代性的，定義的新內容會取代舊的內容。而且只能運用在下層類別ｏｖｅｒｒｉｄｉｎｇ上層類別的方法。而且限制相當嚴格：

l 方法名稱必須相同。

l 運算結果型別若是基本資料型別，必須完全一樣。

l 運算結果型別若是類別，可以是其下層類別。
例：
　　上層類別：
　　　　Object test(){}
　　下層類別：
Integer test(){}//合法
　　　　String test(){}//合法
　 int test(){}//不合法,AutoBoxing在此處不適用

l 參數列無論是個數或型別，必須完全一樣。若稍有不同，即為ｏｖｅｒｌｏａｄｉｎｇ。

l 存取限制修飾詞，可以一樣或更寬鬆，但是不可以更嚴格。
（ｐｒｉｖａｔｅ－＞ｄｅｆａｕｌｔ－＞ｐｒｏｔｅｃｔｅｄ－＞ｐｕｂｌｉｃ）
例：
　　上層類別：
　　　　protected void test(){}
　　下層類別：
　　　　protected void test(){}//合法
　　　　public void test() {}//合法
　　 　void test(){}//不合法,不宣告即為default。

l 方法ｔｈｒｏｗｓ的Ｅｘｃｅｐｔｉｏｎ的個數，可以一樣或比較少，但是不能更多。(Ｃｈｅｃｋｅｄ　Ｅｘｃｅｐｔｉｏｎ)
例：
　　上層類別：
　　　　void test()throws IOException,SQLException{}
　　下層類別：
void test()throws IOException{}//合法
　　　　void test()throws SQLException{}//合法
　 void test()throws IOException,TimeoutException{}//不合法

l 方法ｔｈｒｏｗｓ的Ｅｘｃｅｐｔｉｏｎ，可以是上層類別ｔｈｒｏｗｓ的Ｅｘｃｅｐｔｉｏｎ的子Ｅｘｃｅｐｔｉｏｎ，但不可以是父Ｅｘｃｅｐｔｉｏｎ。（Ｃｈｅｃｋ　Ｅｘｃｅｐｔｉｏｎ）
例：
　　上層類別：
　　　　void test()throws IOException {}
　　下層類別：
void test()throws FileNotFoundException{}//合法
　 void test()throws Exception{}//不合法

l 不可以ｏｖｅｒｒｉｄｉｎｇ上層類別中宣告為ｆｉｎａｌ的方法。

l 沒有辦法ｏｖｅｒｒｉｄｉｎｇ上層類別中宣告為ｓｔａｔｉｃ的方法。
下層類別中的類別方法成員的名稱，可以和上層類別中的類別方法成員的名稱一樣。但這不是ｏｖｅｒｒｉｄｉｎｇ。因為這些方法是屬於類別，不屬於物件，和物件無關。

l 不可以ｏｖｅｒｒｉｄｉｎｇ上層類別中宣告為ｐｒｉｖａｔｅ的方法。

現在，我們再回頭看一下抽象類別（ａｂｓｔｒａｃｔ　ｃｌａｓｓ）。抽象類別有兩種：１、類別中沒有抽象方法，但類別宣告為抽象類別。２、類別中有抽象方法，所以類別也必須宣告為抽象類別。
針對第一種抽象類別，下層類別繼承後，只要下層類別不要宣告ａｂｓｔｒａｃｔ，則下層類別就不是抽象類別。
但是第二種抽象類別就比較複雜，下層類別繼承時，便繼承了上層類別中宣告的抽象方法，所以下層類別中就擁有了抽象方法。此時有兩種處理方式：１、將下層類 別也宣告為抽象類別，禁止建構成物件。２、ｏｖｅｒｒｉｄｉｎｇ所有抽象方法，讓下層類別中，沒有抽象方法，則下層類別便不必宣告為抽象類別。
下層類別繼承了一般類別之後，是否ｏｖｅｒｒｉｄｉｎｇ上層類別的方法，可以自行決定。但是，若繼承了抽象類別，則是一定要ｏｖｅｒｒｉｄｉｎｇ抽象方法。也就是說：抽象類別規範了下層類別一定要定義的方法。
例：
上層類別：
abstract class SuperClass{}
下層類別：
class SubClass extends SuperClass{}//合法
abstract class SubClass extends SuperClass{}//合法
上層類別：
abstract class SuperClass{
　abstract public void value();
}

下層類別：
abstract class SubClass extends SuperClass{}//合法
class SubClass extends SuperClass{
　public void value(){}
}//合法，已重新定義（定義為不執行任何敍述句）
class SubClass extends SuperClass{
　public void value(int a){}
}//不合法，未重新定義（此程式碼為overloading）
class SubClass extends SuperClass{
　void value(){}
}//不合法，上層類別中的存取修飾詞為public，下層類別不宣告代表
//default,其限制性嚴格於public。
　
３－２　ｏｖｅｒｒｉｄｉｎｇ　ｅｑｕａｌｓ
物件的比對有兩種，第一種是比對：「是否為同一個物件」。第二種是比對：「兩個物件的值是否相同」。
例：
String a=new String(”Java”);
String b=new String(”Java”);
System.out.println(a==b);
System.out.println(a.equals(b));
列印結果：false true。
上面的範例程式碼，在很久很久以前我們做過。我們也得到一個結論，用“＝＝”是比較參考變數ａ及參考變數ｂ是否代表同一個物件，ｅｑｕａｌｓ用來比較物件 值是否相同。這個結論，對Ｓｔｒｉｎｇ類別及Ｗｒａｐｐｅｒ　Ｃｌａｓｓｅｓ類別所建構的物件而言，是對的。但是對其他類別所建構的物件，則未必。例 ＳｔｒｉｎｇＢｕｆｆｅｒ，雖然一樣是運算字串值的類別，但是此類別的物件呼叫ｅｑｕａｌｓ（）時，比較的並不是物件的值，而是和“＝＝”一樣，比對是否 為同一個物件。
任何類別從Ｏｂｊｅｃｔ繼承來的ｅｑｕａｓｌ（），其預設的功能都是用來比對是否為同一個物件，也就是和“＝＝”的比對方式是一樣的。但是開發類別的時 候，若是希望本類別的物件呼叫ｅｑｕａｌｓ（）時，可以用特定的方式比對，那就要在類別中ｏｖｅｒｒｉｄｉｎｇ　ｅｑｕａｓｌ（）。至於Ｊａｖａ提供的類 別中，讀者只要知道Ｓｔｒｉｎｇ及Ｗｒａｐｐｅｒ　Ｃｌａｓｓｅｓ有ｏｖｅｒｒｉｄｉｎｇ　ｅｑｕａｌｓ（）就可以，其他類別，自行測試吧！
　
例一：
public class SubClass extends SuperClass{
　int a;
　public boolean equals(Object o){
　　if(o instanceof SubClass && ((SubClass)o).a==this.a){
　　　return true;
　　}else{
　　　return false;
　　}
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　sc.a=10;
　　SubClass sc2=new SubClass();
　　sc2.a=10;
　　System.out.println(sc==sc2);
　　System.out.println(sc.equals(sc2));
　}
}
列印結果：false true。
示範主題：類別ｏｖｅｒｒｉｄｉｎｇ　ｅｑｕａｌｓ（）。
　
ｅｑｕａｌｓ中的判斷句內容，是正確的寫法，而且一定要依照此精神撰寫，讀者可以先略過，等了解後續章節中介紹的多型之後，再回頭研究。但是，如果不按照此精神，只要運算結果是布林值，編譯還是會過，但是日後的邏輯錯誤，可就夠你頭大了。
　
例二：
public boolean equals(SubClass o){
　if(o instanceof SubClass && ((SubClass)o).a==this.a){
　　return true;
　}else{
　　return false;
　}
}
將例一中ｅｑｕａｌｓ（Ｏｂｊｅｃｔ　ｏ）修改為ｅｑｕａｌｓ（ＳｕｂＣｌａｓｓ　ｓ），其他不變更。
列印結果：false true。
示範主題：失敗的ｏｖｅｒｒｉｄｉｎｇ。
　
　總麼失敗了？列印結果不是一樣嗎？錯！大錯！非常錯！這是ｏｖｅｒｌｏａｄｉｎｇ不是ｏｖｅｒｒｉｄｉｎｇ。Ｏｂｅｊｃｔ中的ｅｑｕａｌｓ的參數設為 Ｏｂｊｅｃｔ型別，下層類別ｏｖｅｒｒｉｄｉｎｇ時，自然也要把參數設為Ｏｂｊｅｃｔ型別，因為本方法要能夠接受任何型別的物件為參數。以本例的寫法，若 是參數為本類別物件，會呼叫本例撰寫的方法，但若是參數為非本類別物件時，呼叫的卻是Ｏｂｊｅｃｔ預設的ｅｑｕａｌｓ（），也就是這個類別的 ｅｑｕａｌｓ（）有兩個，而日後你可能會花一個月的時間，才找得到這種邏輯錯誤，寃啊！
　
３－３　ｏｖｅｒｒｉｄｉｎｇ　ｈａｓｈＣｏｄｅ
ｈａｓｈＣｏｄｅ（）的運算結果是一個代表本物件的整數值，它是Ｊａｖａ執行內部運算時，識別物件的依據之一（例：部份集合物件中，用來排列的依據）。如果此方法的運算結果和Ｊａｖａ期望的不一樣，可能會造成某些運算的錯誤。
　
例一：
public class SubClass{
　int a;
　int b;
　public int hashCode(){
　　return (a*b)^8;
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　sc.a=10;
　　sc.b=20;
　　SubClass sc2=new SubClass();
　　sc2.a=20;
　　sc2.b=30;
　　System.out.println(sc.hashCode());
　　System.out.println(sc2.hashCode());
　}
}
列印結果：192　592。
示範主題：ｏｖｅｒｒｉｄｉｎｇ　ｈａｓｈＣｏｄｅ（）。
　
ｈａｓｈＣｏｄｅ（）的運算結果只要是ｉｎｔ值，編譯便合法，但卻不見得符合Ｊａｖａ的期望。除了應該以類別中的資料成員依照固定的運算式來運算之外，Ｊａｖａ期望你能依照下列原則來設計ｈａｓｈＣｏｄｅ（）：

l 若兩個物件，用ｅｑｕａｌｓ比對的結果為ｔｒｕｅ時，其執行ｈａｓｈＣｏｄｅ（）的運算結果一定要相同。

l 若兩個物件，執行ｈａｓｈＣｏｄｅ（）的運算結果不相同時，則它們用ｅｑｕａｌｓ比對的結果必須為ｆａｌｓｅ。

l 若兩個物件，執行ｈａｓｈＣｏｄｅ（）的運算結果相同時，則它們用ｅｑｕａｌｓ比對的結果並不一定要ｔｒｕｅ。
因為不一樣類別的物件呼叫ｈａｓｈＣｏｄｅ（）的運算結果有可能相同，但其ｅｑｕａｌｓ（）卻一定為ｆｌａｓｅ。

l 若兩個物件，用ｅｑｕａｌｓ比對的結果為ｆａｌｓｅ時，其執行ｈａｓｈＣｏｄｅ（）的運算結果完全沒有理會的必要。

要讓ｈａｓｈＣｏｄｅ（）和ｅｑｕａｌｓ（）有上述的關連，最簡捷的方式，就是：「用ｅｑｕａｌｓ（）中，執行比對的成員，來運算ｈａｓｈＣｏｄｅ（）的值」。
　
例：
class HashCodeTest{
　int a,b;
　public boolean equals(Object o){
　　if(o instanceof HashCodeTest){
　　　HashCodeTest hc=(HashCodeTest)o;
　　　if(this.a=hc.a && this.b=hc.b)
　　　　return true;
　　　}
　　　return false;
　　}
　public int hashCode(){
　　return (a+b)^8;
　}
}
示範主題：以ｅｑｕａｌｓ（）中比對用的成員來運算ｈａｓｈＣｏｄｅ（）的值。
　
4. ｓｕｐｅｒ
下層類別繼承上層類別的所有成員，那麼下層類別建構成物件時，Ｊａｖａ要如何配置記憶體空間給下層類別中並沒有宣告，而是繼承自上層類別的資料成員呢？請看以下執行流程：
１‧配置上層類別宣告的實體資料成員，並給予預設值及初始化。
２‧執行上層類別的建構方法。
３‧配置下層類別宣告的實體資料成員，並給予預設值及初始化。
４‧執行下層類別的建構方法。
當然若有一層以上的上層類別，自然是從最上層的上層類別開始執行。
　
４－１　上層類別建構方法的宣告
下層類別建構方法執行之前，一定會呼叫上層類別的建構方法。也就是說：即使下層類別的建構方法中，沒有指定呼叫上層類別的建構方法，Ｊａｖａ也會預設呼叫上層類別的建構方法。
但這個時候就要注意了，Ｊａｖａ預設呼叫的是沒有參數的上層類別建構方法，如果上層類別中沒有沒參數的建構方法，就會造成編譯錯誤。
　
例一：
class SuperClass{}
public class SubClass extends SuperClass{
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　}
}
本例編譯成功，因為下層類別預設的建構方法，執行時預設會呼叫上層類別中沒有參數的建構方法，而上層類別中有一個預設的沒有參數的建構方法。
　
例二：
class SuperClass{
　SuperClass(int a){}
}
public class SubClass extends SuperClass{
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　}
}
本例編譯錯誤，因為上層類別中已經沒有預設的沒有參數的建構方法。
　
例三：
class SuperClass{
SuperClass(){}
　SuperClass(int a){}
}
public class SubClass extends SuperClass{
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　}
}
本例編譯成功，因為上層類別中有自訂的沒有參數的建構方法。
　
例四：
class SuperClass{
　SuperClass(int a){}
}
public class SubClass extends SuperClass{
　public SubClass(){}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　}
}
本例編譯錯誤，下層類別自訂的建構方法中，沒有指定呼叫上層類別的建構方法時，預設會呼叫上層類別中，沒有參數的建構方法。
　
例五：
class SuperClass{
　SuperClass(int a){}
}
public class SubClass extends SuperClass{
　public SubClass(){
　　super(8);
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　}
}
本例編譯成功，因為在下層類別的建構方法中，指定呼叫上層類別的有參數的建構方法。指定呼叫上層類別的敍述句一定要置於第一行。
　
結論：任何類別的建構方法中，第一個執行的敍述句，一定是呼叫上層類別的建構方法（ｓｕｐｅｒ（）），或呼叫本類別的建構方法（ｔｈｉｓ（））。
　
４－２　上層類別成員的存取
下層類別本來就可以存取繼承自上層類別中，存取限制宣告為允許下層類別存取的成員。本節指的是被下層類別ｏｖｅｒｒｉｄｉｎｇ的成員。
　
例一：
class SuperClass{
　private int a=5,b=8;
　int getValue(){
　　return a*b;
　}
}
public class SubClass extends SuperClass{
　int c=3;
　int getValue(){
　　return super.getValue()*c;
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　System.out.println(sc.getValue());
　}
}
列印結果：１２０。
示範主題：因為上層類別的資料成員均設為ｐｒｉｖａｔｅ，下層類別中無法存取，要取得其運算值就一定要呼叫ｇｅｔＶａｌｕｅ（），但下層類別中又已經 ｏｖｅｒｒｉｄｉｎｇ　ｇｅｔＶａｌｕｅ（），所以必須用ｓｕｐｅｒ‧ｇｅｔＶａｌｕｅ（）才能呼叫到上層類別定義的ｇｅｔＶａｌｕｅ（）。
　
例二：
class SuperClass{
　int a=5;
}
public class SubClass extends SuperClass{
　int a=3;
　int getValue(){
　　return super.a*a;
　}
　public static void main(String[] args){
　　SubClass sc=new SubClass();
　　System.out.println(sc.getValue());
　}
}
列印結果：１５。
示範主題：用ｓｕｐｅｒ‧資料成員，也可以存取上層類別中被下層類別覆蓋的資料成員。
　
４－３　上層類別的初始化區塊
下層類別可以指定執行上層類別中的某一個建構方法，就代表寫在上層類別的建構方法中的程式敍述不一定會執行。那麼希望無論下層類別是否指定呼叫都一定要執行的程式敍述就可以寫在初始化區塊。當然初始化區塊也一樣分為實體及類別兩種。
例：
public class SubClass extends SuperClass{
　{
　　System.out.println("Sub Block");
　}
　SubClass(){
　　System.out.println("Sub Constractor");
　}
　static{
　　System.out.println("Sub Static Block");
　}
　public static void main(String[] args){
　　SubClass jt=new SubClass();
　　SubClass jt2=new SubClass();
　}
}
class SuperClass{
　static{
　　System.out.println("Super Static Block");
　}
　{
　　System.out.println("Super Block");
　}
　SuperClass(){
　　System.out.println("Super Constractor");
　}
}
列印結果：Super Static Block　Sub Static Block
　　　　　Super Block　Super Constractor　Sub Block　Sub Constractor
　　　　　Super Block　Super Constractor　Sub Block　Sub Constractor
示範主題：１、無論類別或實體初始化區塊，都是先執行上層類別的區塊。２、上層類別的建構方法執行完畢之後，才執行下層類別的初始化區塊。
　
5. 認證重點
５－１　Ｏｂｊｅｃｔ

ｊａｖａ‧ｌａｎｇ‧Ｏｂｊｅｃｔ是Ｊａｖａ所有類別的上層類別，也就是任何Ｊａｖａ的類別都一定擁有Ｏｂｊｅｃｔ中宣告的成員方法。

任意物件，只要是在需要轉換為字串的運算式之中，Ｊａｖａ都會自動呼叫該件的ｔｏＳｔｒｉｎｇ（）。

任何類別從Ｏｂｊｅｃｔ繼承來的ｅｑｕａｓｌ（），其預設的功能都是用來比對是否為同一個物件，也就是和“＝＝”的比對方式是一樣的。

ｈａｓｈＣｏｄｅ（）的運算結果是一個代表本物件的整數值，它是Ｊａｖａ執行內部運算時，識別物件的依據之一（例：集合物件中，用來排序的依據）。如果此方法的運算結果和Ｊａｖａ期望的不一樣，可能會造成某些運算的錯誤。

５－２　ｅｘｔｅｎｄｓ

每個類別只能有一個上層類別，若沒有宣告上層類別，則此類別的上層類別預設為Ｏｂｊｅｃｔ。

類別繼承了上層類別中的所有成員，只是並非所有成員都可以任意存取。

上層類別中宣告為ｐｒｉｖａｔｅ的成員，下層類別有繼承，但是不能存取。

上層類別中宣告為ｐｒｏｔｅｃｔｅｄ的成員，不同ｐａｃｋａｇｅ的下層類別，可以在類別中以直接存取的方式存取，但是不能建構成物件之後以物件存取，同一個ｐａｃｋａｇｅ的下層類別可以用任意方式存取。

上層類別中宣告為ｐｕｂｌｉｃ的成員，下層類別中可以用任意方式存取。

上層類別中未宣告存取限制的成員，同一個ｐａｃｋａｇｅ的下層類別可以用任意方式存取，不同ｐａｃｋａｇｅ的下層類別中，不可以存取。

５－３　ｏｖｅｒｒｉｄｉｎｇ

下層類別中重新定義上層類別中宣告的實體方法成員，稱之為「ｏｖｅｒｒｉｄｉｎｇ」。

本類別建構的物件，呼叫方法的時候，執行的是本類別中自行定義的內容。

但是ｏｖｅｒｒｉｄｉｎｇ是有取代性的，定義的新內容會取代舊的內容。而且只能運用在下層類別ｏｖｅｒｒｉｄｉｎｇ上層類別的方法。

ｏｖｅｒｒｉｄｉｎｇ的方法名稱必須相同。

ｏｖｅｒｒｉｄｉｎｇ的運算結果型別若是基本型別 ，必須完全一樣。

ｏｖｅｒｒｉｄｉｎｇ的運算結果型別若是類別，可以是其下層類別。

ｏｖｅｒｒｉｄｉｎｇ的參數列無論是個數或型別，必須完全一樣。若稍有不同，即為ｏｖｅｒｌｏａｄｉｎｇ。

ｏｖｅｒｒｉｄｉｎｇ的存取限制修飾詞，可以一樣或更寬鬆，但是不可以更嚴格。

ｏｖｅｒｒｉｄｉｎｇ的方法ｔｈｒｏｗｓ的Ｅｘｃｅｐｔｉｏｎ的個數，可以一樣或比較少，但是不能更多。(Ｃｈｅｃｋｅｄ　Ｅｘｃｅｐｔｉｏｎ)

ｏｖｅｒｒｉｄｉｎｇ的方法ｔｈｒｏｗｓ的Ｅｘｃｅｐｔｉｏｎ，可以是上層類別ｔｈｒｏｗｓ的Ｅｘｃｅｐｔｉｏｎ的子Ｅｘｃｅｐｔｉｏｎ，但不可以是父Ｅｘｃｅｐｔｉｏｎ。（Ｃｈｅｃｋ　Ｅｘｃｅｐｔｉｏｎ）

不可以ｏｖｅｒｒｉｄｉｎｇ上層類別中宣告為ｆｉｎａｌ的方法。

沒有辦法ｏｖｅｒｒｉｄｉｎｇ上層類別中宣告為ｓｔａｔｉｃ的方法。
下層類別中的類別方法成員的名稱，可以和上層類別中的類別方法成員的名稱一樣。但這不是ｏｖｅｒｒｉｄｉｎｇ。因為這些方法是屬於類別，不屬於物件，和物件無關。

不可以ｏｖｅｒｒｉｄｉｎｇ上層類別中宣告為ｐｒｉｖａｔｅ的方法。

下層類別繼承了一般類別之後，是否ｏｖｅｒｒｉｄｉｎｇ上層類別的方法，可以自行決定。但是，若繼承了抽象類別，則是一定要ｏｖｅｒｒｉｄｉｎｇ抽象方法。也就是說：抽象類別規範了下層類別一定要定義的方法。

ｈａｓｈＣｏｄｅ（）的運算結果只要是ｉｎｔ值，編譯便合法，但卻不見得符合Ｊａｖａ的期望。

若兩個物件，用ｅｑｕａｌｓ比對的結果為ｔｒｕｅ時，其執行ｈａｓｈＣｏｄｅ（）的運算結果一定要相同。

若兩個物件，執行ｈａｓｈＣｏｄｅ（）的運算結果不相同時，則它們用ｅｑｕａｌｓ比對的結果必須為ｆａｌｓｅ。

若兩個物件，執行ｈａｓｈＣｏｄｅ（）的運算結果相同時，則它們用ｅｑｕａｌｓ比對的結果並不一定要ｔｒｕｅ。

若兩個物件，用ｅｑｕａｌｓ比對的結果為ｆａｌｓｅ時，其執行ｈａｓｈＣｏｄｅ（）的運算結果完全沒有理會的必要。

５－４　ｓｕｐｅｒ

下層類別建構方式執行之前，一定會呼叫上層類別的建構方法。

下層類別的建構方法中，即使沒有指定呼叫上層類別的建構方法，Ｊａｖａ也會預設呼叫上層類別的建構方法。

Ｊａｖａ預設呼叫的是沒有參數的上層類別建構方法，如果上層類別中沒有沒參數的建構方法，就會造成編譯錯誤。

指定呼叫上層類別的敍述句一定要置於第一行。

任何類別的建構方法中，第一個執行的敍述句，一定是呼叫上層類別的建構方法（ｓｕｐｅｒ（）），或呼叫本類別的建構方法（ｔｈｉｓ（））。

用ｓｕｐｅｒ‧資料成員，也可以存取上層類別中被下層類別覆蓋的資料成員及方法成員。

無論類別或實體初始化區塊，都是先執行上層類別的區塊。

上層類別的建構方法執行完畢之後，才執行下層類別的初始化區塊。