《疯狂Java讲义精粹》读书笔记10 ------ 闭包(Closure) 和回调

==================《疯狂Java讲义精粹》读书笔记10 ------  闭包(Closure) 和回调========================

　　闭包是一种能背调用的对象，他保存了创建它的作用的信息，Java中可以把非静态内部类当成面向对象领域的闭包。

　　回调就是某个方法一旦获得内部内对象的引用后，就可以在合适的时候反过来调用外部类的实例方法。

 

　　假设有这样的一个场景：
　　　　一个人，首先他是一个程序员，他的工作是敲代码。但是他除了是以为程序员之外，他还是一名教师，他的工作还可以在讲台上讲课。
　　那么怎么来实现这个场景呢？
　　首先，我们可以定义两个类(或者接口)，分别叫Teacher 和 Programmer ； 然后定义另一个类叫TeacherProgrammer，这个类继承了Teacher和Programmer，可以使用一个内部类通过闭包和回调来实现两种不同的工作方式。

　　下面是一种实现的方式：

/**
 * 闭包和回调
 * @author 《疯狂的Java讲义精粹》
 *
 */

/**
 * Teacher接口
 */
interface Teacher{
    void work();
}

/**
 * Programmer 类
 */
class Programmer{
    private String name;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public Programmer(){}
    public Programmer(String name){
        this.name = name;
    }
    
    public void work(){
        System.out.println(getName() + "在灯下认真敲代码、、、、、");
    }
}

/**
 * TeacherProgrammer 继承了Programmer类
 * 在内部使用内部内实现回调外部类的方法teach()
 */
public class TeacherProgrammer extends Programmer{
    public TeacherProgrammer(){}
    public TeacherProgrammer(String name){
        super(name);
    }
    
    //教学工作依然由TeacherProgrammer类定义
    private void teach(){
        System.out.println(getName()+ "教师在讲台上讲解、、、、、、");
    }
    
    private class Closure implements Teacher{
        public void work(){
            teach();//闭包
        }
    }
    
    //返回一个非静态内部类的引用，允许外部类通过该非静态内部类引用来回调外部类的方法
    public Teacher getCallbackReference(){
        return new Closure();
    }
    
    public static void main(String[] args) {
        TeacherProgrammer tp = new TeacherProgrammer("CocoonFan");
        tp.work();//调用Programmer的work()方法
        tp.getCallbackReference().work();//调用Teacher类的work()方法
    }
}

输出结果：

CocoonFan在灯下认真敲代码、、、、、
CocoonFan教师在讲台上讲解、、、、、、