Java编程思想：一个小小的控制框架

这个实验我很喜欢，学到了非常多的东西：

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        GreenseController.test();
    }
}
/*
    需求：
        要理解内部类时如果允许简单的创建过程，以及如何使用控制框架的，请考虑
        这样一个控制框架，它的工作是在时间“就绪”的时候执行事件。虽然“就绪”状
        态可以指任何事，但是在本例中是基于时间触发的事件。接下来的问题是，对于
        要控制什么，控制框架并不包含任何具体的信息。那些信息是在实现算法的
        action()部分时，通过继承来提供的。

    案例分析：
        控制框架分为三部分：
            1.事件部分
            2.控制部分
            3.用户实现的控制部分
 */

//事件部分
abstract class Event {
    private long eventTime;
    protected final long delayTime;

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

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

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

//控制部分
class Controller {
    private List<Event> eventList = new ArrayList<>();
    public void addEvent(Event c){eventList.add(c);}

    public void run() {
        /*
            遍历时是针对复制版本的ArrayList进行遍历，删除时是删
            除原来版本的ArrayList
         */
        while (eventList.size() > 0) {
            for (Event e : new ArrayList<>(eventList)) {
                if(e.ready()){
                    System.out.println(e);
                    e.action();
                    eventList.remove(e);
                }
            }
        }
    }
}

//用户实现的控制部分
class GreenhouseControls extends Controller {

    //灯的控制
    private boolean light = false;
    public class LightOn extends Event{

        public LightOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light=true;
        }

        public String toString() {
            return "Greenhouse light is on...";
        }
    }
    public class LightOff extends Event {
        public LightOff(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light = false;
        }

        public String toString() {
            return "Greenhouse light is off...";
        }
    }

    //水的控制
    private boolean water = false;
    public class WaterOn extends Event{

        public WaterOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            water=true;
        }

        public String toString() {
            return "Greenhouse water is on...";
        }
    }
    public class WaterOff extends Event {
        public WaterOff(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            water = false;
        }

        public String toString() {
            return "Greenhouse water is Off...";
        }
    }

    //恒温器的控制
    private String thermostat = "day";
    public class ThermostatNight extends Event{
        public ThermostatNight(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            thermostat = "night";
        }

        public String toString(){
            return "Greenhouse thermostat is night...";
        }
    }
    public class ThermostatDay extends Event {
        public ThermostatDay(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            thermostat = "day";
        }

        public String toString(){
            return "Greenhouse thermostat is day...";
        }
    }

    //演示action()方法中，再创建一个匿名类
    /*
        Bell逻辑：
            一点添加了Bell事件，则Bell的action()方法被调用时
            会在原始版本的EventList中添加一个Bell事件，也就是
            说，除了手动的清除掉Bell事件，否则Bell事件将会永远
            处于事件流中。
     */
    public class Bell extends Event{
        public Bell(long delayTime) {
            super(delayTime);
        }

        /*
            这个会造成循环事件添加吧？但会，因为run方法中
            是对ArrayList进行了一个复制~
         */
        @Override
        public void action() {
            addEvent(new Bell(delayTime));
        }

        public String toString() {
            return "Bing!";
        }
    }

    /*
        Restart逻辑：
            Restart事件自己维护了一部分事件流，当Restart事件流被调用时
            它首先将自己维护的那一部分事件流添加原始版本的eventList中，
            然后重新设置下自己的触发事件，并将自己也放入到原始版本的
            eventList流中。这就时说，Restart事件中的流，将会永永远远的
            被执行，不会被抛弃
     */
    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);
            }
        }

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

        public String toString() {
            return "Restarting system.";
        }
    }

    public static class Terminate extends Event {
        public Terminate(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            System.exit(0);
        }

        public String toString() {
            return "Terminating...";
        }
    }

}

class GreenseController {
    public static void test() {
        GreenhouseControls gc = new GreenhouseControls();

        gc.addEvent(gc.new Bell(900));
        Event[] eventList = {
                gc.new ThermostatDay(0),
                gc.new LightOn(200),
                gc.new LightOff(400),
                gc.new WaterOn(600),
                gc.new WaterOff(800),
                gc.new ThermostatDay(1400),
        };
        gc.addEvent(gc.new Restart(2000, eventList));

        gc.addEvent(new GreenhouseControls.Terminate(800000000));

        gc.run();
    }
}