復用類
7.7向上轉型
- 由導出類轉型成基類,在繼承圖上是向上移動的,因此一般稱為向上轉型.
- 由于向上轉型是從一個較專用類型向通用類型轉換,所以總是很安全的,也就是說,導出類是基類的一個超集.它可能比基類含有更多的方法,它必須至少具備基類中所含有的方法.再向上轉型的過程中,類借口唯一可能發生的事情是丟失方法,而不是獲取它們.這就是為什么編譯器在"未曾明確表示轉型"或"未曾制定特殊標記"的情況下,仍然允許向上轉型的原因.
- 再論組合與繼承:生成和使用程序代碼最有可能采用的方法就是直接將數據和方法包裝進一個類中,并使用該類的對象.應當慎用繼承這一技術,一個最清晰判斷是否要使用繼承的方法就是問一問自己是否需要從新類向基類進行向上轉型.如果必須向上轉型,則繼承是必要的;但如果不需要,則應當好好考慮自己是否需要繼承.
7.8final關鍵字
class Value{
int i;
public Value(int i){this.i = i;}
}
public class FinalData {
private static Random rand = new Random(47);
private String id;
public FinalData(String id){this.id = id;}
//Can be compile-time constants;
private final int valueOne = 9;
private static final int VALUE_TWO = 9;
private static final int VALUE_THREE = 99;
//tYPICAL PUBLIC constant
public final int i4 = rand.nextInt(20);
static final int INT_5 = rand.nextInt(20);
private Value v1 = new Value(11);
private final Value v2 = new Value(22);
private static final Value VAL_3 = new Value (33);
//Arrays
private final int []a = {1,2,3,4,5,6};
public String toString(){
return id + ": " + "i4 = " + i4 + " , INT_5 = " +INT_5;
}
public static void main(String[] args) {
FinalData fd1 = new FinalData("fd1");
//!fd1.valueOne++;//Error:can't change value
fd1.v2.i++;//Object isn't constant!
fd1.v1 = new Value(9);//OK -- not final
for (int i = 0; i < fd1.a.length; i++) {
fd1.a[i]++;//Object isn't constant!
}
//! fd1.v2 = new Value(0);//Error: Can't
//! fd1.VAL_3 = new Value(1);//change reference
//! fd1.a = new int[3];
print(fd1);
print("Creating new FinalData");
FinalData fd2 = new FinalData("fd2");
print(fd1);
print(fd2);
}
}
[圖片上傳失敗...(image-f88b83-1535024645933)]
- 對于對象引用,final使引用恒定不變.一旦引用被初始化指向一個對象,就無法再把它改為指向另一個對象.然而,對象自身卻是可以被修改的.如上圖
- 使用final方法的原因有兩個:
- 第一個原因是把方法鎖定,以防任何繼承類修改它的含義.這是處于設計的考慮,想要確保在繼承中使方法行為保持不變,并且不會被覆蓋.
- 第二個原因是效率.不過現在已經不需要final方法來進行優化了.
- 類中所有的private方法都隱式地指定為是final的.由于無法取用private方法,所以也就無法覆蓋它.
- 如果某方法為private,它就不是基類接口的一部分.他僅是一些隱藏于類中的程序代碼,只不過時具有相同的名稱而已.
//兩個類中的private final方法并不作為接口出現只是各自的方法,如果用向上轉型來調用會出現錯誤
class WithFinals{
//Identical to "private" alone;
private final void f(){print("WithFinals.f()");}
//Also automatically "final"
private void g(){print("WithFinal.g()");}
}
class OverridingPrivate extends WithFinals{
private final void f(){
print("OverridingPrivate.f()");
}
private void g(){
print("OverridingPrivate.g()");
}
}
7.9 繼承和初始化
- 運行過程:在Beetle上運行Java時,所發生的第一件事情就是試圖訪問Beetle.main()(一個static方法).于是加載器開始啟動并找出Beetle類的編譯代碼(在名為Beetle.class的文件中).在對它進行加載的過程中,編譯器注意到它有一個基類(這是由于關鍵字extends得知的),于是它繼續進行加載.不管你是否打算產生一個該基類的對象,這都要發生(請嘗試將對創建代碼注釋掉,以證明這一點). 如果該基類還有其自身的基類,那么第二個基類就會被加載,如此類推.接下來,根基類中的static初始化即會被執行,然后是下一個導出類,以此類推.這種方式很重要,因為導出類中的static初始化可能會依賴于基類成員能否被正確初始化.
多態
最重要的一點就是 <b>編譯看左邊，運行看右邊</b>(域操作不是)
- 在有多態的類中,編譯器怎樣才能指導加載的是哪一個類呢?實際上編譯器無法得知.有必要研究一下綁定問題.
- 將一個方法調用同一個方法主體關聯起來稱作綁定.若在程序執行前進行綁定(如果有的話,由編譯器和連接程序實現),叫做前期綁定.困惑(因為它是面向過程的語言中不需要選擇就默認的綁定方式.)
- 要知道究竟調用那個方法,辦法就是后期綁定.它的含義就是在運行時根據對象的類型進行綁定.后期綁定也叫做動態綁定或者運行時綁定.
- java中除了static方法和final方法(private方法屬于final方法)之外,其他所有方法都是后期綁定.這意味著通常情況下,我們不必判定是否應該進行后期綁定--它會自動發生.
類似于Shape s = new Circle();
- 只有非private方法才可以被覆蓋;但是還需要密切注意覆蓋private方法的現象,這時雖然編譯器不會報錯,但是也不會按照我們所期望的來執行.確切的說,在導出類中,對于基類中的private方法,最好采用不同的名字.
//當Sub對象轉型為Super引用時,任何域訪問操作都將由編譯器解析,因此不是多態的. 當然這種情況很少遇到首先,你通常會將所有的域都設置成private,因此不能直接訪問它們,其副作用是只能調用方法來訪問.另外你可能不會對基類中的域和導出類中的域賦予相同的名字,因為這種做法容易令人混淆.
class Super{
public int field = 0;
public int getField(){return field;}
}
class Sub extends Super{
public int field = 1;
public int getField(){return field;}
public int getSuperField(){return super.field;}
}
public class FieldAccess {
public static void main(String[] args) {
Super sup = new Sub();
System.out.println("sup.field = " + sup.field + ", sup.getField() = " + sup.getField() );
Sub sub = new Sub();
System.out.println("sub.field = " + sub.field + ", sub.getField() = " + sub.getField() + ", sub.getSuperFild = " + sub.getSuperField());
}
}/*Output:
sup.field = 0,sup.getField() = 1
sub.field = 1,sub.getField() = 1,sub.getSuperField() = 0
*///:~
- 如果某個方法是靜態的,它的行為就不具有多態性.
- 靜態方法是于類,而并非與單個的對象相關聯的.
