Thinking in Java：第十章-内部类

1：内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起。并控制位于内部的类的可视性。

2：如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须具体的指明这个对象的类型：OutClass.InnerClass。当生成一个内部类对象时，此对象与制造它的外围对象之间就有了一种联系，所以它能访问其外围对象的所有成员。

3：每个内部类都可以独立的继承一个（接口的）实习，所以无论外围类是否已经继承了某个实现，对于内部类都没有影响。也就是说，内部类和接口一起实现了java的多重继承机制。

4：内部类实例：

/**
 * Created by ivalue on 2017/12/21.
 */

// p208
public abstract class Event {

    private long eventTime;

    private long delayTime;

    public Event(long delayTime) {
        this.delayTime = delayTime;
        start();
    }

    public void start() {
        eventTime = System.nanoTime() + delayTime;
    }

    public boolean ready() {
        return (System.nanoTime() >= eventTime);
    }

    public abstract void action();
}

Event 类是要控制的事件的基类

/**
 * Created by ivalue on 2017/12/21.
 */

// p208
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 : event)
            for (Event e : new ArrayList<Event>(eventList)) {
               if (e.ready()) {
                   System.out.println(e);
                   e.action();
                   eventList.remove(e);
               }
            }
        }
    }
}

Controller类控制类的基类

/**
 * Created by ivalue on 2017/12/21.
 */

// p209
public class GreenHouseController extends Controller {

    private boolean light = false;

    public class LightOn extends Event {
        public LightOn(long delayTime) {
            super(delayTime);
        }
        public void action() {
            light = true;
        }

        @Override
        public String toString() {
            return "light is on";
        }
    }

    public class LightOff extends Event {
        public LightOff(long delayTime) {
            super(delayTime);
        }
        public void action() {
            light = false;
        }
        @Override
        public String toString() {
            return "light is off";
        }
    }

    private boolean water = false;

    public class WaterOn extends Event {
        public WaterOn(long delayTime) {
            super(delayTime);
        }
        public void action() {
            water = true;
        }

        @Override
        public String toString() {
            return "water is on";
        }
    }

    public class WaterOff extends Event {
        public WaterOff(long delayTime) {
            super(delayTime);
        }
        public void action() {
            water = false;
        }

        @Override
        public String toString() {
            return "water is off";
        }
    }


    public class Restart extends Event {

        private Event[] eventList;

        public Restart (long delayTime, Event[] eventList) {
            super(delayTime);
            this.eventList = eventList;
            for (Event e :  eventList) {
                addEvent(e);
            }
        }

        public void action() {
            for (Event e : eventList) {
                e.start();
                addEvent(e);
            }
            start();
            addEvent(this);
        }

        @Override
        public String toString() {
            return "restart is on";
        }
    }

    public static void main(String[] args) {

        GreenHouseController gc = new GreenHouseController();

        //gc.addEvent(gc.new LightOn(200));

        Event[] eventList = {
                gc.new LightOn(200),
                gc.new LightOff(500),
                gc.new WaterOn(800),
                gc.new WaterOff(1200)
        };

        gc.addEvent(gc.new Restart(2000, eventList));

        gc.run();
    }
}

这是一个简单的命令设计模式，Restart事件反复运行，而且每次都会将eventList 加载到GreenHouseController对象中。