Java中的闭包与回调

一个难点,写到自己的blog,一天看一次,不怕看不懂

 

闭包 是一个可调用的对象,它记录了一些信息,这些信息来自于创建他的作用域

通过这个定义,可以看出内部类是面向对象的闭包

因为这不仅包含外围类对象("创建内部类的作用域")的信息

还自动拥有一个指向此外围类对象的引用

在此作用域内,内部类有权操作所有的成员,包括private

 

Java最引人争议的问题之一就是,人们认为Java应该包含某种类似指针的机制,

以允许回调(callback),通过回调,对象能够携带一些信息,

这些信息允许他在稍后的某个时刻调用初始的对象

通过内部类提供闭包的功能是完美的解决方案,他比指针更灵活,更安全

 

 

interface Incrementable
...{
    void increment();
}

class Callee1 implements Incrementable
...{
    private int i=0;
    public void increment()
    ...{
        i++;
        System.out.println(i);
    }
}

class MyIncrement
...{
    void increment()
    ...{
        System.out.println("Other operation");
    }
    
    static void f(MyIncrement mi)
    ...{
        mi.increment();
    }
}

class Callee2 extends MyIncrement
...{
    private int i=0;
    private void incr()
    ...{
        i++;
        System.out.println(i);
    }

    private class Closure implements Incrementable
    ...{
        public void increment()
        ...{
            incr();
        }
    }
    
    Incrementable getCallbackReference()
    ...{
        return new Closure();
    }
}

class Caller
...{
    private Incrementable callbackReference;
    Caller(Incrementable cbh)
    ...{
        callbackReference=cbh;
    }
    
    void go()
    ...{
        callbackReference.increment();
    }
    
}


public class Callbacks
...{
    public static void main(String [] args)
    ...{
        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();
    }
}