public class Test {
    public static void main(String[] args) {
        Callbacks.test();
    }
}

/*
    為什麽需要內部類：
        1.可以認為內部類提供了某種進入外圍類的窗口
        2.每個內部類都能獨立的繼承一個接口的實現，所以無論外圍類是否已經繼承了某個
        接口的實現，對於內部類都是沒有影響的
        3.可以解決多重繼承的問題

    內部類一些其他的優點：
        1.內部類可以有多個實例，每個實例都有自己的狀態信息，並且與其他外圍類對象的信息相互獨立
        2.在單個外圍類中，可以讓多個內部類以不同的方式實現同一個接口，或繼承同一個類。
        3.創建內部類對象的時刻並不依賴外部類對象的創建（這個有問題吧？）
        4.內部類沒有令人疑惑的“is-a”關系，它就是一個獨立的實體
 
 
*/
interface A { }
interface B { }
class X implements A,B{}
class Y implements A{
    B makeB(){return new B(){}; };
}

class D {}
abstract class E {}
class Z extends D{
    E makeE(){ return new E(){}; }
}

/*
    需求：
        人們認為Java應該包含某種類似指針的機制，以允許回調。通過回調，對象能夠攜帶
        一些信息，這些信息允許它在稍後的某個時刻調用初始的對象。（將函數指針傳給這
        個對象，然後由這個對象通過函數指針調用初始對象的方法。）



    案例分析：
        我感覺這個案例好復雜啊，莫名奇妙的類關系。Callee翻譯為被召集者，Caller翻譯為
        召集者。召集者手中持有一個實現了Increment的對象，用來記錄自己召集的人被召集了
        多少次，這就想每個包工頭手上有一個人，它分配活給這個工人，同時還要記錄下這個工
        人幹了多少次活。對於callee1，它直接實現了Increment接口，從單一職能的設計原
        則上來講，這種設計分工並不明確。對於callee2，由於系統強迫它繼承了MyIncrement
        （這其中涉及到方法名沖突方面的問題，我還沒看到這部分，理論上，我覺得也可以去實現
        一下Increment接口，做實驗也確實可以），而且MyIncrement有個方法，系統要求必須
        在數據增加時調用，這時候我們就使用回調了
 
 
*/

interface Incrementable {
    void increment();
}

/*
    一種非常簡陋的方案
 */
class Callee1 implements Incrementable {
    private int i = 0;
    @Override
    public void increment() {
        i++;
        System.out.println(i);
    }
}



/*
    利用內部類實現的一種方案
 */
class MyIncrement {
    
 
public void increment() { System.out.println("Other operation..."); }
    static void f(MyIncrement mi){mi.increment();}
}

class Callee2  extends MyIncrement{
    private int i = 0;

    public void increment() {
        super.increment();
        i++;
        System.out.println(i);
    }

    private class Closure implements Incrementable {
        @Override
        public void increment() {
            Callee2.this.increment();
        }
    }

    Incrementable getCallbackReference() {
        return new Closure();
    }
}

/*
    需求部分
 */

class Caller{
    private Incrementable callbackReference;

    public Caller(Incrementable callbackReference) {
        this.callbackReference = callbackReference;
    }

    void go() {
        callbackReference.increment();
    }
}

class Callbacks {
    public static void test() {
        Callee1 c1=new Callee1();
        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();
    }
}

Java編程思想：為什麽要使用內部類