續內部類

10.8 為什么需要內部類

1. 每個內部類都能獨立地繼承自一個(接口的)實現,所以無論外圍類是否已經繼承了某個(接口的)實現,對于內部類都沒有影響.
2. 內部類可以繼承多個具體的或抽象的類的能力.從這個角度看,內部類使得多重繼承的繼承解決方案變得完整.接口解決了部分問題,而內部類有效地實現了"多重繼承".也就是說,內部類允許繼承多個非接口類型(譯注:類或抽象類)

class D{}//具體類
abstract class E{}//抽象類
class Z extends D{
    E makeE(){
        return new E(){};
    }
}
public class MultiImplementation {
    static void takesD(D d){}
    static void takesE(E e){}
    public static void main(String[] args){
        Z z = new Z();
        takesD(z);
        takesE(z.makeE());
    }
}

1. 如果不需要解決"多重繼承"問題,那么自然可以用別的方式編碼,而不需要使用內部類.但如果使用內部類,還可以獲得其他一些特性:
   1. 內部類可以有多個實例,每個實例都有自己的狀態信息,并且與其外圍類對象的信息相互獨立.
   2. 再單個外圍類中,可以讓多個內部類以不同的方式實現同一個接口,或繼承同一個類.
   3. 創建內部類對象的時刻并不依賴與外圍類對象的創建
   4. 內部類并沒有令人迷惑的"is - a"關系;他就是一個獨立的實體

//分析程序的時候要分開來看先看Callee1然后看Callee2的運行
interface Incrementable{
    void increment();
}
class Calleel implements Incrementable{
    private int i =0;
    @Override
    public void increment() {
        i++;
        print(i);
    }
}
class MyIncrement{
    public void increment(){
        print("Other operatortion");
    }
    static void f(MyIncrement mi){
        mi.increment();
    }
}
//if your class must implement increment() in
//some other way ,you must use an inner class
//上面的注釋很重要,就是如果你想要使用interface Increment中的increment方法只能用內部類因為繼承中的MyIncrement中已經有了一個increment方法
class Callee2 extends MyIncrement{
    private int i = 0;
    public void increment(){
        super.increment();
        i++;
        print(i);
    }
    private class Closure implements Incrementable{
        public void increment(){
            //Specify outer-class method. therwise
            //you'd get an infinite recursion
            Callee2.this.increment();//用外部類來調用方法
        }
    }
    Incrementable getCallbackReference(){
        return new Closure();
    }
}
//Caller的構造器需要一個Incrementable的引用作為參數,然后在以后的某個時刻,Caller對象可以使用此引用回調Callee類
//回調的價值在于它的靈活性--可以在運行時動態地解決需要調用什么方法.
class Caller{
    private Incrementable callbackReference;
    Caller(Incrementable cbh){callbackReference = cbh;}
    void go(){callbackReference.increment();}
}
public class Callbacks {
    public static void main(String[] args) {
        Calleel c1 = new Calleel();
        Callee2 c2 = new Callee2();
        MyIncrement.f(c2);
        Caller caller1 = new Caller(c1);
        Caller caller2 = new Caller(c2.getCallbackReference());
        caller1.go();
        caller1.go();
        caller2.go();
        caller2.go();
    }
}

1. P208有一個設計模式內部類的設計可以研究一下

10.9內部類的繼承

1. 語法: enclosingClassReference.super()

class WithInner{
    class Inner{}
}
public class InheritInner extends WithInner.Inner{
    //! InheritInner(){} //Won't complile
    InheritInner(WithInner wi){
        wi.super();
    }

    public static void main(String[] args) {
        WithInner wi = new WithInner();
        InheritInner ii = new InheritInner(wi);
    }
}

10.10內部類可以被覆蓋嗎

1. 下面程序解釋現在BigEgg2.Yolk通過extends Egg2.Yolk明確的繼承此內部類,并覆蓋了其中的方法.insertYolk()方法允許BigEgg2將它自己的Yolk對象向上轉型為Egg2中的引用y.
2. 使用當g()調用y.f()時,覆蓋后的新版的f()被執行.第二次調用Egg2.Yolk(),結果好似BigEgg2.Yolk的構造器調用了其基類的構造器.

//看得我賊蒙圈等下我debug調試一下
//1.進入main方法
//2.找到public BigEgg2()構造方法
//3.找到public Egg2()構造方法
//4.初始化private Yolk y = new Yolk();此時Yolk=null
//5.找到public Yolk()構造方法
//6.輸出print("Egg2.Yolk()");
//7.此時創建Yolk對象private Yolk y = new Yolk();
//8.輸出print("New Egg2()");
//9.回到public BigEgg2()運行 insertYolk(new Yolk());
//10.找到 public Yolk()再找到父類Yolk并輸出print("Egg2.Yolk()");
//再輸出 print("BigEgg2.Yolk()");
//11.運行insertYolk(Yolk yy)方法并為y賦值yy
//12.運行e2.g();找到 public void g()
//13.運行y.f()運行子類中的新f()
//14.輸出 print("BigEgg2.Yolk()");
class Egg2{
    protected class Yolk{
        public Yolk(){
            print("Egg2.Yolk()");
        }
        public void f(){
            print("Egg2.Yolk.f()");
        }
    }
    private Yolk y = new Yolk();
    public Egg2(){
        print("New Egg2()");
    }
    public void insertYolk(Yolk yy){
        y = yy;
    }
    public void g(){
        y.f();
    }
}
public class BigEgg2 extends Egg2{
    public class Yolk extends Egg2.Yolk{
        public Yolk(){
            print("BigEgg2.Yolk()");
        }
        public void f(){
            print("BigEgg2.Yolk()");
        }
    }
    public BigEgg2(){
        insertYolk(new Yolk());
    }

    public static void main(String[] args) {
        Egg2 e2 = new BigEgg2();
        e2.g();
    }
}

1. 當繼承了某個外圍類的時候,內部類并沒有發生什么特別神奇的變化.這兩個內部類是完全獨立地兩個實體,各自在自己的命名空間內.當然明確地繼承某個內部類也是可以的.

10.11局部內部類

1. 使用局部內部類而不是使用匿名內部類的唯一理由就是,我們需要一個已命名的構造器,或者需要重載構造器,而匿名內部類只能用于實例初始化.
2. 局部內部類訪問外部類方法的局部變量,這個局部變量必須是有效final--->將這個變量變成常量,存儲到常量池中,保證聲明周期延長.