内部类和控制框架

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

在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方法,将事件都得到运行,这里如果在启动类的使用没有使用参数,那么这个就将一直循环这几个事件

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

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

able陈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值