摘要：而并不是父類對(duì)象的引用，而只是給編譯器的一個(gè)提示性質(zhì)的標(biāo)志?；蛘咦远x的提示在編譯的時(shí)候使用當(dāng)前子類的父類定義的構(gòu)造器去初始化當(dāng)前對(duì)象。所以，總結(jié)起來(lái)，的用法歸為兩種一是可以調(diào)用父類構(gòu)造器，二是可以調(diào)用父類方法。

開篇
Java是一門不那么簡(jiǎn)單也不那么復(fù)雜的語(yǔ)言，Java里面有很多問(wèn)題和特性是容易被使用者忽視的，這些問(wèn)題也許會(huì)難住新手，同時(shí)也許會(huì)是老手不小心跌入的無(wú)故之坑，只有精于對(duì)基礎(chǔ)的提煉才能最大程度地解決類似的疑問(wèn)。所以，在讀Cay.Horstmann的《Java核心技術(shù)》的過(guò)程中，我記錄下這些所謂的易忽略的問(wèn)題，這些問(wèn)題將會(huì)持續(xù)更新在我的這個(gè)Segment Fault的博客下，也算是激勵(lì)自己重新挖掘這些基礎(chǔ)問(wèn)題的內(nèi)涵。這個(gè)博客將以原書中的章節(jié)為分割，大概會(huì)是每章一篇，持續(xù)更新，每篇的內(nèi)容也不會(huì)一次全部寫完，視我個(gè)人對(duì)問(wèn)題的理解和我的閱讀進(jìn)度而定。

super這個(gè)關(guān)鍵字和this其實(shí)是完全不同的，因?yàn)閠his實(shí)際上是一個(gè)真實(shí)存在的引用，是一個(gè)缺省的傳入方法的隱式參數(shù)，引用當(dāng)前的對(duì)象，所以可以完全當(dāng)做一個(gè)正常的引用來(lái)使用。而super并不是父類對(duì)象的引用，而只是給javac編譯器的一個(gè)提示性質(zhì)的標(biāo)志。當(dāng)使用如下的super時(shí)：

super.someFunction(); 提示javac在編譯這個(gè)someFunction()方法的時(shí)候去使用該類的父類定義的someFunction()方法，這一般是在當(dāng)前的子類也定義了同樣名字的someFunction()方法的時(shí)候去使用的。

super()；或者自定義的super(type Par); 提示javac在編譯的時(shí)候使用當(dāng)前子類的父類定義的構(gòu)造器去初始化當(dāng)前對(duì)象。

所以，總結(jié)起來(lái)，super的用法歸為兩種：一是可以調(diào)用父類構(gòu)造器，二是可以調(diào)用父類方法。

子類對(duì)象的初始化過(guò)程：子類執(zhí)行子類的初始化方法，初始化方法里會(huì)先執(zhí)行缺省的super()方法（寫不寫這個(gè)super方法都會(huì)執(zhí)行），也就是說(shuō)會(huì)先初始化出一個(gè)父類對(duì)象，然后再執(zhí)行其他的初始化部分，最終之前初始化出的父類對(duì)象將會(huì)成為子類對(duì)象，這也是多態(tài)性的起始，因?yàn)楸举|(zhì)上來(lái)講，子類對(duì)象是有父類對(duì)象的結(jié)構(gòu)的。

在繼承存在的時(shí)候，初始化的過(guò)程就變得異常復(fù)雜，但是卻仍然遵循著初始化的原則：先加載類和屬于類的static屬性，然后創(chuàng)建類的對(duì)象，因?yàn)橛欣^承的問(wèn)題，所以在初始化子類對(duì)象的時(shí)候要先初始化其父類的對(duì)象。
這個(gè)例子極佳地說(shuō)明了這個(gè)復(fù)雜的過(guò)程，可以使用單步調(diào)試給出初始化的全過(guò)程：

class FatherClass {
    
    private static FatherClass f = new FatherClass();
    static {
        b = 10;
        System.out.println("father static block");
    }
    
    {
        System.out.println("father object block");
    }
    
    static int b = 5;
    
    public FatherClass() {
        System.out.println("father constructor...");
        System.out.println( "b = " + b);
        
    }
}

public class ChildClass extends FatherClass {
    static int a = 5;
    static {
        a = 10;
        System.out.println("child static block");
    }
    
    {
        System.out.println("chid object block");
    }
    
    private static ChildClass t1 = new ChildClass();
    
    public ChildClass() {
        System.out.println("child constructor...");
        System.out.println("a = " + a);
    }
    
    public static void main(String[] args) {
        ChildClass test = new ChildClass();
    }
}

這是運(yùn)行的初始化結(jié)果：

先加載類，所以順序執(zhí)行static代碼塊和static屬性聲明,按照先父類再子類的順序加載類，

father object block
//加載父類執(zhí)行f的初始化時(shí)激發(fā)了父類對(duì)象的初始化，對(duì)象的初始化塊執(zhí)行
father constructor...   
//對(duì)象的構(gòu)造器
b = 0
//未經(jīng)初始化的屬性的缺省值
father static block
//f的初始化完成，執(zhí)行父類的靜態(tài)初始化快，父類加載完畢
child static block
//子類初始化開始，執(zhí)行子類的靜態(tài)初始化塊
father object block
//t1的初始化激發(fā)了子類對(duì)象的初始化，并進(jìn)而激發(fā)了父類對(duì)象的初始化，執(zhí)行父類對(duì)象初始化塊
father constructor...
//執(zhí)行父類的構(gòu)造器
b = 5
//父類的域?qū)傩砸呀?jīng)被初始化，父類對(duì)象初始化完成
chid object block
//子類對(duì)象開始初始化，對(duì)象初始化塊執(zhí)行
child constructor...
//子類對(duì)象的構(gòu)造器執(zhí)行
a = 10
//子類對(duì)象的域?qū)傩砸驯怀跏蓟?，完成子類的加載
father object block
//執(zhí)行父類對(duì)象的初始化
father constructor...
b = 5
chid object block
//執(zhí)行子類對(duì)象的初始化
child constructor...
a = 10

如果使用最簡(jiǎn)單的辦法去說(shuō)明什么是多態(tài)，那么這樣寫無(wú)疑是有力的：

FatherClass child = new ChildClass();
child.funcOverride();

這個(gè)的意思就是說(shuō)棧中創(chuàng)建的父類對(duì)象可以引用堆中的子類對(duì)象，那么這個(gè)過(guò)程為什么可以實(shí)現(xiàn)呢？從兩個(gè)方面可以說(shuō)明：
從對(duì)象初始化的角度來(lái)說(shuō)，和上一節(jié)我們說(shuō)到的一樣，子類對(duì)象的初始化意味父類先加載，子類再加載，父類對(duì)象初始化，子類對(duì)象初始化，所以子類對(duì)象實(shí)際上就是在父類對(duì)象的基礎(chǔ)上生成的，因此父類對(duì)象當(dāng)然可以引用子類對(duì)象了；
從方法覆蓋的角度來(lái)說(shuō)，父類對(duì)象的方法子類對(duì)象都有，因此對(duì)父類方法的使用實(shí)際上就會(huì)成為對(duì)子類方法的使用，這個(gè)過(guò)程不能反過(guò)來(lái)，也就是說(shuō)子類對(duì)象的方法并不是父類對(duì)象都有，因此不能使用子類對(duì)象去引用父類對(duì)象。

jvm為了實(shí)現(xiàn)多態(tài)情況下方法執(zhí)行的快速判斷，會(huì)為每個(gè)類維護(hù)一個(gè)虛方法表（和C++實(shí)現(xiàn)多態(tài)的虛擬函數(shù)有關(guān)），這個(gè)方法表表述了該類型對(duì)象在執(zhí)行某方法時(shí)應(yīng)該執(zhí)行的方法具體是哪個(gè)，理論上在child去執(zhí)行funcOverride()方法的時(shí)候會(huì)先去看ChildClass是否擁有覆蓋的funcOverride()方法，如果有則執(zhí)行這個(gè)，如果沒(méi)有覆蓋則執(zhí)行父類的同名方法，而實(shí)際上為避免做這些可能要進(jìn)行多次的判斷，jvm為類準(zhǔn)備的虛方法表固化這種方法對(duì)應(yīng)關(guān)系，進(jìn)而可以快速定位要執(zhí)行的方法。

舉個(gè)例子：

class FatherClass{
    public void func1(){
        System.out.println("func from FC");
    }
    public void func2(){
        System.out.println("func from FC");
    }
}

class ChildClass extends FatherClass{
    @Override
    public void func1() {
        System.out.println("func from CC");
    }
}

那么，jvm為類維護(hù)的虛方法表類似(不要去考慮和這個(gè)問(wèn)題無(wú)關(guān)的Object自帶方法)：

VirtualMethodTableOfFatherClass:
FatherClass.func1()     --      FatherClass.func1()
FatherClass.func2()     --      FatherClass.func2()

VirtualMethodTableOfChildClass:
ChildClass.func1()     --      ChildClass.func1()
ChildClass.func2()     --      FatherClass.func2()

每個(gè)類都源自O(shè)bject類，所以也就不得不接受Object父類帶來(lái)的基本方法，比如這個(gè)麻煩的額equals方法，在Object類中的equal方法非常簡(jiǎn)單，就是一句話：

public boolean equals(Object obj) {
    return (this == obj);
}

這句話用于判斷當(dāng)前這個(gè)棧中變量引用的堆中對(duì)象是否和參數(shù)變量引用的堆中對(duì)象和同一個(gè)對(duì)象，所以這其實(shí)是個(gè)很抽象的“相等”，因?yàn)檫@就像廢話一樣。

所以一個(gè)完善的equals方法應(yīng)該恰當(dāng)?shù)刂赋鰞蓚€(gè)對(duì)象相等的內(nèi)涵，即時(shí)兩個(gè)變量并不是指向同一塊內(nèi)存，如果他們的某些被指定的屬性是一樣的，那么就可以算作是“相等”。所以，我們有以下這樣對(duì)對(duì)象相等的考慮：
1.是否指向同一塊堆中內(nèi)存空間，也就是是否引用同一對(duì)象，如果是，這肯定相等；
2.是否是空引用的比較，如果不是，則才可能相等；
3.是否具有同樣的類型，如果是，則才可能相等；
4.是否具有繼承鏈上的一系列類型，如果是，則可能相等；
5.是否某些屬性是相等的，如果是，則才可能相等。
基于上面的考慮，我們可以有這樣的例子來(lái)寫出一個(gè)相對(duì)完善的equals方法：
（特別注意的是，equals的參數(shù)是Object類型的，只有這樣才能覆蓋Object的equals方法）

class Employee{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object obj) {
        if(this  == obj)
            return true;
        if(obj == null)
            return false;
        if(this.getClass() != obj.getClass())
            return false;
        Employee tempEmployee = (Employee)obj;
        return tempEmployee.getName().equals(name);
    }
}
public class TestClass {
    public static void main(String[] args) {
        Employee employee1 = new Employee();
        employee1.setName("boss");
        Employee employee2 = new Employee();
        employee2.setName("boss");
        System.out.println(employee1.equals(employee2));
        System.out.println(employee2.equals(employee1));
        
    }
}

我們都知道ArrayList這樣的數(shù)據(jù)集合就是Java快速處理批量數(shù)據(jù)的容器，那么對(duì)這個(gè)容器里的每個(gè)數(shù)據(jù)元素而言，是把每個(gè)元素的值拷貝到容器中呢還是只是把它們的引用拷貝到容器中去呢？從效率和資源占用的角度來(lái)說(shuō)，ArrayList選擇了引用拷貝，只是把“構(gòu)成”這個(gè)集合的數(shù)據(jù)元素的引用放到了容器中，這個(gè)例子說(shuō)明了這個(gè)問(wèn)題：

并不是每次“添加”一個(gè)數(shù)據(jù)元素到容器中，而是“引用”一個(gè)元素到容器中，如果每次都拿一個(gè)數(shù)據(jù)元素做引用，最后所有的容器元素索引都指向一個(gè)引用的地址。

class Employee {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class TestClass {
    public static void main(String[] args) {
        Employee employee = new Employee();
        ArrayList list = new ArrayList();
        for (int i = 0; i < 5; i++) {
            employee.setName("name" + i);
            list.add(employee);
        }
        for (Employee each : list) {
            System.out.println(each.getName());
        }
    }
}

未完成。。。