|
第6章 重復運用classes
一．繼承（inheritance）
1． 在derived class中overriding某個函數(shù)時，只能覆寫base class中的接口，即base class中的public或protected或friendly函數(shù)。如果試圖overriding一個private函數(shù)，雖然編譯通過，但實際上你只是在derived class中添加了一個函數(shù)。如
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中的一個函數(shù)，所以當試圖在（a）處通過多態(tài)來調用prt()時，會發(fā)生錯誤。如果把（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的構造函數(shù)，但必須放在構造函數(shù)的第一行，并且只能在構造函數(shù)中運用。
2.3 初始化順序為：
1） 加載代碼（.class文件）
2） 初始化class的靜態(tài)成員，初始化順序了“從里到外”，即從baseclass開始。
3） 在derived class的構造函數(shù)中調用base class的構造函數(shù)。
如果在derived class的構造函數(shù)中沒有通過super()顯式調用調用base class的構造函數(shù)，編譯器會調用bass class的default構造函數(shù)并自動生成相應的調用語句，從而產生一個base class實例。如果在derived class的構造函數(shù)中通過super()顯示調用了父類的構造函數(shù)，則調用所指定的構造函數(shù)。調用構造函數(shù)的調用順序是“從里到外”。
4） 調用derived class的構造函數(shù)。
＊＊：當base class沒有default構造函數(shù)時，必須在derived class的構造函數(shù)中通過super顯示調用base class的構造函數(shù)。
例：下面代碼的初始化過程為：
1） 裝載ExplicitStatic的代碼（裝載ExplicitStatic.class文件）。
2） 發(fā)現(xiàn)ExplicitStatic有關鍵字extends，裝載ExplicitStatic的baseclass的代碼（裝載Cleanser.class文件）。
3） 發(fā)現(xiàn)Cleanser有關鍵字extends，裝載Cleanser的baseclass的代碼（裝載Base.class文件）。
4） 初始化Base class中的靜態(tài)成員。
5） 初始化Cleanser class中的靜態(tài)成員。
6） 初始化ExplicitStatic class中的靜態(tài)成員。
如果把（c）處的代碼注釋掉，那么初始化工作到此就結束了。
7） 為ExplicitStatic對象分配存儲空間，并把存儲空間初始化為0。
8） 在ExplicitStatic class的構造中調用super("ExplicitStatic")（在ExplicitStatic class的構造函數(shù)中顯式調用父類的構造函數(shù)），試圖產生一個Cleanser class實例。
9） 為Cleanser對象分配存儲空間，并把存儲空間初始化為0。
10） 由于Cleanser class又是繼承自Base class，會在Cleanser class的構造函數(shù)中通過super()（由于沒有顯式調用父類的構造函數(shù)，所以自動調用父類的default構造函數(shù)）調用父類的構造函數(shù)，試圖產生一個Cleanser class實例。
11） 產生一個Base class實例。先初始化成員變量，再調用構造函數(shù)。
12） 回到Cleanser class，產生一個實例。首先初始化Cleanser class中的成員數(shù)據(jù)，再執(zhí)行構造函數(shù)Cleanser(String a)中的其余部分。
|
