黑马程序员－交_通_管_理_系_統

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

面向对象的分析与设计

设计一个Road类来表示路线

每个Road对象代表一条路线，总共有12条路线

即系统中总共要产生12个Road实例对象

每条路线上随机增加新的车辆，增加到一个集合中保存。

每条路线每隔1秒都会检查控制本路线的灯是否为绿

是，则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。

package com.isoftstone.interview.traffic2;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/** 
 * 每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。 
 * 每条路线上随机增加新的车辆，增加到一个集合中保存。 
 * 每条路线每隔10秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。 
 * @author 
 * 
 */
public class Road {
	//1.首先这条路可以放车，就需要一个集合存放车辆
	List vechicels = new ArrayList();
	
	//2.每条路线都有自己的名字,每个路线的车也有自己的名字
	private String name = null;
	public Road (String name){
		this.name = name;
		
		//模拟车辆不断随机上路的过程 
		ExecutorService pool = Executors.newSingleThreadExecutor();
		pool.execute(new Runnable(){
			@Override
			public void run() {
				try {
					Thread.sleep((new Random().nextInt(10)+1)*1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				for(int i=0; i<1000; i++){
					vechicels.add(Road.this.name+"_"+i);
				}
			}
		});
		
		//3.每隔10秒检查对应的灯是否为绿，是则放行一辆车    (做个定时器  Scheduled：预订    FixedRate：固定频率)
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		
		timer.scheduleAtFixedRate(
				new Runnable(){
					@Override
					public void run() {//这里面执行的是将道路上的车辆移走
						if(vechicels.size()>0){
							boolean lighted = Lamp.valueOf(Road.this.name).isLighted();//这里通过路的名字name，获取自己的灯，并调用自己灯的方法判断灯是否为绿
							if(lighted){
								System.out.println(vechicels.remove(0)+" is traversing通过!");
							}
						}
					}
				}, 
				10, 
				10, 
				TimeUnit.SECONDS);
	}
}

设计一个Lamp类来表示一个交通灯，总共有12条路线，所以，系统中总共要产生12个交通灯

每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。

右拐弯的路线本来不受灯的控制

但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯

只是这些灯为常亮状态，即永远不变黑。
除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组

所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮

与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯

在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。

每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯。
无论在程序的什么地方去获得某个方向的灯时，每次获得的都是同一个实例对象

所以Lamp类改用枚举来做显然具有很大的方便性，永远都只有代表12个方向的灯的实例对象。

package com.isoftstone.interview.traffic2; 

/*
 * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
 * 
 * 东East 西West 南South 北North
 * 
 * 从南开始；南-->北     南-->西    
 * 从东开始；东-->西     东-->南
 * 从北开始；北-->南     北-->东
 * 从西开始；西-->东     西-->北
 * 
 * 下面是四个拐弯:
 * 由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制,所以，可以假想它们总是绿灯。
 * 
 * 南-->东拐、东-->北拐、北-->西拐、西-->南拐
 * 
 */
public enum Lamp {
	
	//函数里面传递的是：对应的灯，下一个灯，现在的灯状态
	S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("S2E","S2N",false),
	
	/*下面元素表示与上面的元素的相反方向的灯，它们的“相反方向灯”和“下一个灯”应忽略不计！*/
	N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
	
	 /*由南向东和由西向北等右拐弯的灯不受红绿灯的控制，所以，可以假想它们总是绿灯*/
	S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
	
	private Lamp(String opposite, String next, boolean lighted){
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}

	/*定义一个成员变量，表示当前灯的状态是否为绿*/ 
	private boolean lighted;
	
	//*定义一个成员变量，表示与当前灯同时为绿的对应方向，用字符串表示*/ 
	private String opposite;
	
	/*定义一个成员变量，当前灯变红时下一个变绿的灯，用字符串表示*/
	private String next;
	
	public boolean isLighted(){
		return lighted;
	}
	
	//灯的两个方法，红和绿
	public void light(){
		this.lighted = true;
		//让对应的灯也跟着亮
		if(opposite!=null){
			Lamp.valueOf(opposite).light();
		}
		//此处的name()方法是枚举的方法
		System.out.println(name() + "lamp is green,下面总共应该有6个方向能看到汽车穿过");
	}
	
	   /** 
	    * 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿 
	    * @return 下一个要变绿的灯 
	    */
	public Lamp balckOut(){
		this.lighted = false;
		//让对应的灯也跟着灭
		if(opposite!=null){
			Lamp.valueOf(opposite).balckOut();
		}
		/*如果还有下一个灯，就将下个灯变亮*/
		Lamp nextLamp = null;
		if(next != null){
			nextLamp = Lamp.valueOf(next);//这里接收下一个灯，然后调用light方法，将其变亮
			nextLamp.light();
			System.out.println("绿灯从" + name() + "---->切换为" + next);
		}
		return nextLamp;  
		//这里使用了一个设计技巧：当将下一个灯变绿时，这里将返回一个绿灯的状态，blackOut将接收到一个绿灯的值。当灯的控制器调用blackOut时，他就得到了一个绿灯
	}
}

设计一个LampController类，灯的控制器。

package com.isoftstone.interview.traffic2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/*
 * 《灯的控制器》
 * CurrentLamp：当前的灯
 */
public class LampController {
	private Lamp currentLamp;//记录当前的灯是哪个
	public LampController(){
		currentLamp = Lamp.S2N;//刚开始就将南向北的灯是亮的
		currentLamp.light();
		
		//亮了以后，它就每隔10秒让这个灯亮红，让下个灯变绿
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				new Runnable(){
					@Override
					public void run() {
						currentLamp = currentLamp.balckOut();//这里得到的是当前变绿的灯。因为balckOut经过特殊设计，它接收的是返回值nextLamp变绿的灯
					}
				}, 
				10, 
				10, 
				TimeUnit.SECONDS);
	}
}

主函数调用

package com.isoftstone.interview.traffic2;

public class MainClass {

	/**主函数，调用
	 * @param args
	 */
	public static void main(String[] args) {
		// 使用数组定义12个路线
		String[] arr = new String[]{"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};
		for(int i=0; i<arr.length; i++){
			new Road(arr[i]);//调用Road，向路线中传递线路的名字
		}
		new LampController();//调用灯的控制器	
	}

}

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------