内部类和控制框架

内部类在控制框架中的作用

在java编程思想中看到的一个例子，感觉对于我自己有很大的启示，所以进行一下整理

public abstract  class  Event{
	private long delayTime ; 
	protected long eventTime ; 
	public Event(long delayTime){
		this.delayTime = delayTime ; 
		start() ;
	}
	public void start(){	//这里start方法没有放在构造器中是为了是一件事件可以被启动多次
		eventTime = System.nanoTime() + delayTime;
	}
	public boolean ready(){	//这里判断是否时间准备完毕
		return System.nanoTime()>=eventTime;
	}
	public abstract void action(){}
}

上面是一个抽象类,在具体使用的时候，只需要给出具体的action方法即可，通过继承可以达到复用的效果

public class Controller {
	private List<Event> eventList = new ArrayList<>();
	public void addEvent(Event c) {eventList.add(c);}
	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);
				}
			}
		}
		
	}
	
}

在这个类中，实现了具体的对事件的控制

• addEvent方法实现了将事件添加到事件队列中的作用
• run方法通过循环判断使得事件队列中的达到条件的事件得到启动，然后使用remove方法将启动过的事件从事件队列中清除

public class GreenHouseControls extends Controller{
	private boolean light = false ; 
	public class LightOn extends Event{
		public LightOn(long delayTime) {super(delayTime);}
		public void action() {
			light = true ;
		}
		public String toString() {return "Light is on";}
	}
	
	public class LightOff extends Event{
		public LightOff(long delayTime) {super(delayTime);}
		public void action() {
			light = false;
		}
		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 ;
		}
		public String toString() {return "Water is on";}
	}
	
	public class WaterOff extends Event{
		public WaterOff(long delayTime) {super(delayTime);}
		public void action() {
			water = false;
		}
		public String toString() {return "Water is off";}
	}
	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 = "Day";
		}
		
		public String toString() {return "Thermostat on day setting";}
		
	}
	
	public class Bell extends Event{
		public Bell(long delayTime) {
			super(delayTime);
		}
		@Override
		public void action() {
			addEvent(new Bell(delayTime));
		}
		public String toString() {return "Bing!";}
	}
	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) {
				e.start();
				addEvent(e);
			}
			start();
			addEvent(this);
		}
		public String toString() {
			return "Restarting System";
		}
	}
	
	public static class Terminate extends Event{
		public Terminate(long delayTime) {super(delayTime);}
		public void action() {System.exit(0);}
		public String toString() {return "Terminating";}
	}
}

这是一个对于温室控制的具体的类，通过使用内部类，使得在一个类中可以完成各种各样的动作
只要将内部类继承事件Event,然后将action方法重写为不同的方法就行了
通过使用内部类，达到了一种目的，可以将对一种事物的不同种响应时间全部都集中在一个类中
达到了对代码的封装
这里有一个很重要的类，也是不同于其他内部类的类，那就是Restart类
这个类可以接受别的事件，并将这些事件存储起来，然后作为依次执行，在Restart类中，action方法最后将自身也加入到了队列中，这使得事件进入到了一个循环中，一直在不停的Restart
在实际的使用中感觉这种框架还是很有用的

public class GreenHouseControler {
	public static void main(String[] args) {
		GreenHouseControls gc = new GreenHouseControls();
		gc.addEvent(gc.new Bell(900));
		Event[] eventList = {
				gc.new ThermostatNight(0),
				gc.new LightOn(200),
				gc.new LightOff(400),
				gc.new WaterOn(600),
				gc.new WaterOn(800),
				gc.new ThermostatNight(1400)
		};
		gc.addEvent(gc.new Restart(2000, eventList));
		if(args.length==1)
			gc.addEvent(
				new GreenHouseControls.Terminate(new Integer(args[0])));
		gc.run();
	}
}

这是一个具体的温室控制的类，这里再创建eventList的时候使用了内部类的创造方法(外部类对象.new 内部类名称)
在这个类中，gc是controler的对象，使用run方法，将事件都得到运行，这里如果在启动类的使用没有使用参数，那么这个就将一直循环这几个事件

在这其中，我感觉最重要的这种思想，将事件和控制相分离，在要添加事件的时候就通过继承抽象的事件类来得到需要的事件，减少了重复的代码，在使用要控制的时候，也将继承控制基类，然后通过覆盖基类中的方法，达到实现对于不同事件的控制，然后就是将一个具体的控制类进行在一个类中进行封装，这样可以使得代码更加的集中，更具有模块性，然后就是具体的需要事件的调用，这种分离的思想我感觉是在任何地方都需要的，将各个不用的模块分割开来，极可能的减少耦合，对于代码的扩展性和重复利用性都很重要