电梯系统OO设计

理论上应该先黑盒用例，分析需要求，系统边界的输入输出，再白盒类图。 但是对于现实世界模拟的OO，个人感觉先emulate现实世界，初步识别类和类之间的关系，再用用例和顺序图丰富、修正类图。

识别类，最主要的原则是封装，数据和数据的操作封装成一个类：

轿厢 box：封装轿厢的状态：位置、方向、静止还是运动，capacity,  pickup列表，目的地列表

楼building：用户请求电梯的媒介，和轿厢box有个一对一关联关系，向轿厢box发call消息，轿厢到达某层，向building发某层open的消息。

从控制驱动的角度，有2种控制流（主动对象）

1）轿厢box：不停地运转，根据请求的情况，运行或者停止等待信号

2）人：1是人向building发消息，building再 forward到box；2）是人向轿厢发消息，设置要去的目的地楼层

和VODController类似，内部一个驻留线程，类似一个状态机运行着，同时多个点可以接收异步消息更新数据。

亮点是一个事件机制，每经过一层，触发一个positionChanged的事件

总结：OO系统，就是一个互相发消息的对象系统，对象之间靠消息交互

常见的控制流模型:

1) 顺序执行，exit

2）无专门驻留线程，完全消息驱动，类似一般的web service，request/response模式。

3) 有一个驻留线程在run, (定时运行或者受信号控制），同时也可以接受异步消息更新数据，为社么说是异步消息，因为它只是通过update数据来影响状态机的运行，不需要返回什么结果。基于工作队列的处理系统也属于这种模型，但更简单，FIFO处理就行，电梯模型的复杂在于，系统会根据当前所有request的情况做一个调度，并不是简单的FIFO。

class Box {
	int direction; // 0 up, 1 down, 2 stopped
	int currentPos; //current position
	int capacity;  // max load
	final static int   MAX_FLOOR = 100;
	volatile boolean destinations[] = new boolean[MAX_FLOOR]; 
	volatile boolean pickups[][] = new boolean[MAX_FLOOR][2]; //0 for up, 1 for down
	int highestTo = -1; // the farest upper floor to go
	int lowestTo = -1; // the farest lower floor to go
	volatile boolean on = true; //on or off
	Building building;
	int numRequest = 0;
	Object signal = new Object();
	
	public void call(int floor, int direction) { 
		synchronized(signal) {
			if (!pickups[floor][direction]) {
				pickups[floor][direction] = true;
				++numRequest;
				if (highestTo < 0 || floor > highestTo) highestTo = floor;
				if (lowestTo < 0 || floor < lowestTo) lowestTo = floor;
				signal.notify();
			}		
		}
	}
	public void setDestination(int floor) {	
		synchronized(signal) { 
			if (!destinations[floor]) {
				destinations[floor] = true;
				++numRequest; 
				signal.notify();
			}		
		}
	}
	public void shutdown() { 
		on = false; 
		synchronized(signal) {			
			signal.notify();
		}
	}
	
	private void open() {building.open(currentPos); /*first open the building door, then the box's*/ } 
	private void close() {building.close(currentPos);}
	private void stop() {}
	private void positionChanged() {	
		if (pickups[currentPos][direction] || destinations[currentPos]) {
			stop();
			open();
			//Thread.sleep(5000);
			close();
			synchronized(signal) {
				if (pickups[currentPos][direction]) {pickups[currentPos][direction] = false; --numRequest;}
				if (destinations[currentPos]) {destinations[currentPos] = false; --numRequest;}
				if (highestTo == currentPos) highestTo = -1;
				if (lowestTo == currentPos) lowestTo = - 1;
			}
			//resume();
		}
	}
	private void run() {
		while (on) {
			synchronized (signal) { 
				if (numRequest == 0) {
					direction = 2; //stopped
					signal.wait(); //wait signal here if no jobs to do					
				}
				//decide up or down, handle upper request first.
				if (highestTo > 0 ) direction = highestTo > currentPos ? 0 : 1;
				else if (lowestTo > 0) direction = lowestTo < currentPos ? 1 : 0;
			}
			
			if (direction == 0) { //up
				for (int i = currentPos + 1; i <= highestTo; ++i) {
					++currentPos;
					positionChanged();
				}
			}
			else if (direction == 1) {//down
				for (int i = currentPos - 1; i >= lowestTo; --i) {
					--currentPos;
					positionChanged();
				}
			}
			
		}
	}
}
//楼building：用户请求电梯的媒介，和轿厢box有个一对一关联关系，向轿厢box发call消息，轿厢到达某层，向buildng发某层open的消息。
class Building {
	Box box;
	public void call(int floor, int direction ) { box.call( floor,  direction);}
	public void open(int floor) {}
	public void close(int floor) {}
}