第6章 重復運用classes

　　一．繼承（inheritance）

　　 1． 在derived class中overriding某個函數時，只能覆寫base class中的接口，即base class中的public或protected或friendly函數。如果試圖overriding一個private函數，雖然編譯通過，但實際上你只是在derived class中添加了一個函數。如

　　 class Cleanser{
　　 private void prt(){//（b）

　　 System.out.println("Cleanser.prt()");
　　 }
　　 }
　　 public class ExplicitStatic extends Cleanser{
　　 public void prt(){
　　 System.out.println("ExplicitStatic.prt()");
　　 }
　　 public static void main(String[] args){
　　 Cleanser x = new ExplicitStatic();
　　 x.prt();//（a）

　　 }
　　 }
　　 因為Cleanser中的prt()是private，所以不能在其derivedclass中被覆寫。ExplicitStatic中的prt()只是ExplicitStatic中的一個函數，所以當試圖在（a）處通過多態來調用prt()時，會發生錯誤。如果把（b）處的private去掉，則結果為
　　 ExplicitStatic.prt()

　　 2． Super的使用

　　 1）通過關鍵字super可以調用當前class的superclass（父類）。

　　 例6.1.1.1
　　 class Base{
　　 Base(){System.out.println("Base()");}
　　 public void scrub() { System.out.println(" Base.scrub()"); }
　　 }
　　 class Cleanser extends Base{
　　 private String s = new String("Cleanser");
　　 public void append(String a) { s+=a; }
　　 public void dilute() { append(" dilute()"); }
　　 public void apply() { append(" apply()"); }
　　 public void scrub() { append(" scrub()"); }
　　 public void print() { System.out.println(s); }
　　 Cleanser(){
　　 System.out.println("Cleanser(): " + s);
　　 }
　　 public static void testStatic(){
　　 System.out.println("testStatic()");
　　 }
　　 public static void main(String[] args){
　　 Cleanser x = new Cleanser();
　　 x.dilute(); x.apply(); x.scrub(); x.print();
　　 }
　　 }
　　 public class ExplicitStatic extends Cleanser{
　　 ExplicitStatic(){
　　 System.out.println("ExplicitStatic()");
　　 }
　　 public void scrub(){
　　 append(" Detergen.scrub()");
　　 super.testStatic();
　　 super.scrub();//調用的是Cleanser.scrub()

　　 }
　　 public void foam() { append(" foam()"); }
　　 public static void main(String[] args){
　　 ExplicitStatic x = new ExplicitStatic();
　　 x.dilute(); x.apply(); x.scrub(); x.foam();
　　 x.print(); System.out.println("Test base class:");
　　 Cleanser.main(args);
　　 testStatic();
　　 }
　　 }
　　 運行結果：

　　 Base()

　　 Cleanser(): Cleanser
　　 ExplicitStatic()

　　 testStatic()

　　 Cleanser dilute() apply() Detergen.scrub() scrub() foam()

　　 Test base class:

　　 Base()

　　 Cleanser(): Cleanser
　　 Cleanser dilute() apply() scrub()

　　 testStatic()

　　 2）通過super來調用superclass中的成員時，調用的是最近成員。

　　 例6.1.1.2
　　 class Base{
　　 protected String baseS = "Base";//（a）

　　 //private String baseS = "Base";
　　 Base(){System.out.println("Base()");}
　　 }
　　 class Cleanser extends Base{
　　 protected String baseS = "Cleanser";//（b）

　　 public String s = new String("Cleanser");
　　 Cleanser(){
　　 System.out.println("Cleanser(): " + s);
　　 }
　　 Cleanser(String a){
　　 System.out.println("Cleanser(" + a + "): s = " + s );
　　 }
　　 }
　　 public class ExplicitStatic extends Cleanser{
　　 String s2 = s;
　　 String baseS = super.baseS; //（c）

　　 ExplicitStatic(){
　　 super("ExplicitStatic");
　　 System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = "
　　 + baseS + "super.baseS = " + super.baseS);
　　 baseS = "ExplicitStatic";
　　 System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
　　 }
　　 public static void main(String[] args){
　　 ExplicitStatic x = new ExplicitStatic();
　　 }
　　 }
　　 結果1：

　　 Base()

　　 Cleanser(ExplicitStatic): s = Cleanser
　　 ExplicitStatic():s2 = Cleanser, baseS = Cleanser,super.baseS = Cleanser
　　 baseS = ExplicitStatic , super.baseS = Cleanser
　　 在上面例子中，在三個class中都存在String bases實例。在ExplicitStatic中如果直接調用baseS，則實際調用的是當前類ExplicitStatic中的baseS（即（c）處的成員）；如果通過super.bases來調用baseS，則調用的是離當前類ExplicitStatic最近的baseS成員，即Cleanser class中的baseS實例（即（b）處），產生的結果如結果1所示。如果把（b）處語句注釋掉，則將調用Base class中的baseS，結果如結果2所示。

　　 結果2：

　　 Base()

　　 Cleanser(ExplicitStatic): s = Cleanser
　　 ExplicitStatic():s2 = Cleanser, baseS = Base,super.baseS = Base
　　 baseS = ExplicitStatic , super.baseS = Base
　　 3． Base class的初始化

　　 2.1 當你產生derived class對象時，其中會包含base class子對象（subobject）。這個子對象就和你另外產生的base class對象一模一樣。

　　 2.2 通過super()可調用base class的構造函數，但必須放在構造函數的第一行，并且只能在構造函數中運用。

　　 2.3 初始化順序為：

　　 1） 加載代碼（.class文件）

　　 2） 初始化class的靜態成員，初始化順序了“從里到外”，即從baseclass開始。

　　 3） 在derived class的構造函數中調用base class的構造函數。

　　 如果在derived class的構造函數中沒有通過super()顯式調用調用base class的構造函數，編譯器會調用bass class的default構造函數并自動生成相應的調用語句，從而產生一個base class實例。如果在derived class的構造函數中通過super()顯示調用了父類的構造函數，則調用所指定的構造函數。調用構造函數的調用順序是“從里到外”。

　　 4） 調用derived class的構造函數。

　　 ＊＊：當base class沒有default構造函數時，必須在derived class的構造函數中通過super顯示調用base class的構造函數。

　　 例：下面代碼的初始化過程為：

　　 1） 裝載ExplicitStatic的代碼（裝載ExplicitStatic.class文件）。

　　 2） 發現ExplicitStatic有關鍵字extends，裝載ExplicitStatic的baseclass的代碼（裝載Cleanser.class文件）。

　　 3） 發現Cleanser有關鍵字extends，裝載Cleanser的baseclass的代碼（裝載Base.class文件）。

　　 4） 初始化Base class中的靜態成員。

　　 5） 初始化Cleanser class中的靜態成員。

　　 6） 初始化ExplicitStatic class中的靜態成員。

　　 如果把（c）處的代碼注釋掉，那么初始化工作到此就結束了。

　　 7） 為ExplicitStatic對象分配存儲空間，并把存儲空間初始化為0。

　　 8） 在ExplicitStatic class的構造中調用super("ExplicitStatic")（在ExplicitStatic class的構造函數中顯式調用父類的構造函數），試圖產生一個Cleanser class實例。

　　 9） 為Cleanser對象分配存儲空間，并把存儲空間初始化為0。

　　 10） 由于Cleanser class又是繼承自Base class，會在Cleanser class的構造函數中通過super()（由于沒有顯式調用父類的構造函數，所以自動調用父類的default構造函數）調用父類的構造函數，試圖產生一個Cleanser class實例。

　　 11） 產生一個Base class實例。先初始化成員變量，再調用構造函數。

　　 12） 回到Cleanser class，產生一個實例。首先初始化Cleanser class中的成員數據，再執行構造函數Cleanser(String a)中的其余部分。