Thinking in java 读书笔记（七.2：内部类：闭包和控制框架）

一、
内部类是就是面向对象的一种闭包形式。
首先说说闭包。最坑爹的闭包应该是JavaScript的闭包了，JS函数外部无法读取函数内的变量，而函数内可以读取外部变量，然后当外部需要读取内部变量时就需要使用闭包(JS一般使用一个function表示闭包)。
而对于Java来说，可以吧函数类比为class，当我们需要读取某个class的某个private的参数可以使用内部类来访问，因为内部类可以透明的访问它所嵌入的外围类的所有成员。
书上例子如下

package com.company.ChildrenClass;
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 myIncrement){
        myIncrement.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;
    Caller(Incrementable callbackReference){
        this.callbackReference = callbackReference;
    }
    void go(){
        callbackReference.increment();
    }
}
/*这里的回调似乎是为了动态扩展
* Callee2由于继承的父类已经存在接口中的方法，想要同时实现父类和接口的方法，
* 需要的就是内部类(其实已经是多继承的一种实现吧),内部类来实现接口，然后提供回调，传出内部类引用
* */
public class CallBacks {
    public static void main(String[] args) {
        Callee1 callee1 = new Callee1();
        Callee2 callee2 = new Callee2();
        MyIncrement.f(callee2);
        Caller caller1 = new Caller(callee1);
        Caller caller2 = new Caller(callee2.getCallBackReference());
        caller1.go();
        caller2.go();
    }
}

二、控制框架
这里引入了第三种设计模式：模板方法。事实上其实应用框架是模板方法的一种实现，而控制框架是一种特殊的应用框架。
应用框架是设计来解决某种特定问题的一组类。运用某个应用程序框架，通常是继承一个或者多个类并且覆盖某些方法，在覆盖的方法中编写解决方案。
有写过JavaFX和Android，这两个应该都是这种应用框架的实现。但是书上用的swing举例。所以这里算是应用框架初探了…。

模板方法最关键的地方是使变量和常量分离

//书中以下示例代码将忽略具体的event细节而设计框架。
public abstract class Event {
    private long eventTime;
    protected final long delayTime;
    public Event(long delayTime){
        this.delayTime = delayTime;

    }
    public void start(){
        //allows restarting
        eventTime = System.nanoTime()+delayTime;//generate start time;
    }
    public boolean ready(){
        return System.nanoTime()>=eventTime;
    }
    public abstract void action();
}



public class Controller {
    private List<Event> eventList = new ArrayList<>();
    public void addEvent(Event event){
        eventList.add(event);
    }
    public void run(){
        while (eventList.size()>0){
            //不是很清楚为什么要用副本
            for (Event e:new ArrayList<Event>(eventList)){
                if (e.ready()){
                    System.out.println(e);
                    e.action();
                    eventList.remove(e);
                }
            }
        }
    }
}

然后内部类和控制框架有什么关心呢，内部类一般用来改写event(至少目前只碰到过这个)。虽然现在自己个人写点东西都喜欢使用lambda表达式，或者直接使用匿名内部类，但是事实上使用内部类来写event可读性高的不是一点两点，还是改城用内部类吧。

//这里不使用书上的实例代码，放个写javafx的实例
//设置JavaFXStage关闭时的动作。
primaryStage.setOnCloseRequest(new WindowsCloseEvent(primaryStage));

class WindowsCloseEvent implements EventHandler<WindowEvent> {

        private Stage stage;

        public WindowsCloseEvent(Stage stage){
            this.stage = stage;
        }

        public void handle(WindowEvent event) {
            event.consume();
            if (!isSendFile&&!isRecFile){
                UserBean clientBean = new UserBean();
                clientBean.setType(-1);
                clientBean.setName(username);
                clientBean.setTimer(DateUtil.getTimer());
                sendMessage(clientBean);
                primaryStage.close();

            }
            if (isRecFile){
                dialogController.setText("正在接受文件无法退出");
                Dialog.show();
            }
            if (isSendFile){
                dialogController.setText("正在发送文件无法退出");
                Dialog.show();
            }
        }
    }

三、内部类的继承、覆盖

public class InheritInner extends WithClass.Inner {
//因为非static的内部类如果外部类没有初始化的话，内部类也就不存在的，
//所以需要传入一个外部类的实例
    InheritInner(WithClass withClass){
        withClass.super();
    }
    public static void main(String[] args) {
        WithClass wi = new WithClass();
    }
}
class WithClass{
    class Inner{}
}
//因为内部类的访问需要通过外部类，所以其实子类是无法覆盖父类的内部类的。