Java内部类应用实例：控制框架

/*
* "控制框架"是应用程序框架的一种特殊类型，受到对事件响应的需要的支配：
* 例如主要用来响应事件的一个系统叫做“由事件驱动的系统”
* 为了理解内部类如何简化“控制框架”的创建和使用，可以认为一个控制框架的工作
* 就是在事件“就绪”以后执行它们。针对“控制框架”需要控制的东西，框架内并没有
* 包含任何特定的信息。
*/

（一）定义“事件”

public abstract class Event {
    private long evtTime;
    public Event(long eventTime)
    {
        evtTime=eventTime;
    }
    public boolean ready()
    {
        return System.currentTimeMillis()>=evtTime;
    }
    abstract public void action();
    abstract public String description();
}
/*
* ready告诉我们何时运行事件
* action是事件就绪后需要调用的方法
* description则提供了和事件有关的文字信息
*/

（二）定义“事件集合”

public class EventSet {
    private Event[] event =new Event[100];
    private int index=0;
    private int next=0;
    public void add(Event e)
    {
        if(index >= event.length)
            return;
        event[index++]=e;
    }
    public Event getNext()
    {
        boolean looped=false;
        int start=next;
        do
        {
            next=(next+1)%event.length;
            if(start==next) //如果下一个又回到start，那么表示已经循环了一次了
                looped=true;
            if((next==(start+1)%event.length) && looped ) //表示经过一次遍历后list已经为空了
                return null;
        }while ( event[next]==null);
        return event[next];
    }
    public void removeCurrent()
    {
        event[next]=null;
    }
}
/*
* index用来跟踪下一个可用的空间
* next帮助我们寻找列表中的下一个事件，了解自己是否已经循环到头
* 在getNext调用后，event对象会从列表中删除，所以getNext会在列表中向前移动时
* 遇到null
*/

（三）定义“事件控制器”

public class Controller {
    private EventSet es=new EventSet();
    public void addEvent(Event c)
    {
        es.add(c);
    }
    public void run()
    {
        Event e;
        while(( e=es.getNext())!=null)
        {
            if( e.ready() )
            {
                e.action();
                System.out.println(e.description());
                es.removeCurrent();
            }
        }
    }
}

（四）实例应用“温室事件控制器”

/*
* 我们无法知道框架的使用者会要求“事件”做什么，
* 那么要怎样“将发生变化的东西和没有变化的东西区分开”呢？
* 我们需要通过创建不同的Event子类来表达出不同的行动，这里就是内部类大显身手的时候了
* （1）在单独一个类里面表达一个控制框架应用的全部实施细节
* 从而完整的封装和那个实施有关的东西。也就是说把所有event都作为内部类来封装
* （2）内部类使我们具体的实施变得更加巧妙，因为可以方便的访问到外部类的任何成员
* 这样带来一定的便利。
*/

public class GreenhouseControls extends Controller {

    private boolean light=false;
    private boolean water=false;
    private String thermostat="Day";
    private class LightOn extends Event
    {

        public LightOn(long eventTime) {
            super(eventTime);
            // TODO Auto-generated constructor stub
        }

        @Override
        public void action() {
            // TODO Auto-generated method stub
            light=true;
        }

        @Override
        public String description() {
            // TODO Auto-generated method stub
            return "Light is on";
        }
    }
    private class LightOff extends Event
    {

        public LightOff(long eventTime) {
            super(eventTime);
            // TODO Auto-generated constructor stub
        }

        @Override
        public void action() {
            // TODO Auto-generated method stub
            light=false;
        }

        @Override
        public String description() {
            // TODO Auto-generated method stub
            return "Light is off";
        }
    }
    //其他事件
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        GreenhouseControls gc=
            new GreenhouseControls();
        long tm=System.currentTimeMillis();
        gc.addEvent(gc.new LightOn(tm));
        gc.run();
    }
}

（五）框架的类图

使用内部类的好处

* （1）在单独一个类里面表达一个控制框架应用的全部实施细节
* 从而完整的封装和那个实施有关的东西。也就是说把所有event都作为内部类来封装
* （2）内部类使我们具体的实施变得更加巧妙，因为可以方便的访问到外部类的任何成员
* 这样带来一定的便利。