交通管理系统

交通灯管理系统

模拟实现十字路口的交通灯管理系统逻辑.
1.路线：总共有南北西东四个方向，每个方向上的车辆都能向周围三个方向行驶，所以总共有十二条路线。
South：南North：北East：东West：西
十二条路线：
S2NS2W S2E
N2S N2W N2E
E2S E2N E2W
W2E W2S W2N
根据需求，每一个灯都有相反方向的灯和下一个灯，所以经简化得到四条路线：水平方向，垂直方向，S2W,W2N.

2.面向对象的分析和设计：
对象：红绿灯，交通灯的控制系统，路线(车辆的集合)
路中存储的是车辆的集合，所以路上有增加和减少车辆的方法，汽车看到自己所在路线的灯变绿了，还需知道前方是否有车，才能穿过去。
实质：捕捉车辆穿过路口的过程，即路上的车辆依次减少的过程。

1.每条路线上都会出现很多车，路线上要随机增加新的车， 在灯绿期间还要每秒钟减少一辆车；
2.每条路线每隔一秒就会检查控制本路线的灯是否为绿灯，如果灯由绿变红，则需要将其下个灯变为路灯。

3.类的代码实现：
1.Road类

				/*
				 * Road对象的描述：当灯变绿了，将路口的车辆依次挪走
				 */
				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;
				public class Road{
					//路是车辆的集合，路上有多少辆车只有路清除
					private List<String> vechicles = new ArrayList<String>();	
					private String name =null;
					//路线的名称不同
					public Road(String name){
						this.name = name;		
						//模拟车辆不断随机上路的过程		
						ExecutorService pool = Executors.newSingleThreadExecutor();
						pool.execute(new Runnable(){
							public void run(){
								for(int i=1;i<1000;i++){
									try {
										//在1-10s内随机上路一辆车
										Thread.sleep((new Random().nextInt(10) + 1) * 1000);
									} catch (InterruptedException e) {
										e.printStackTrace();
									}
									vechicles.add(Road.this.name + "_" + i);
								}				
							}
						});
						//每隔一秒检查对应的灯是否为绿，如果是则挪走一辆车		
						ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
						timer.scheduleAtFixedRate(
								new Runnable(){
									public void run(){
										if(vechicles.size()>0){
											boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
											if(lighted){
												System.out.println(vechicles.remove(0) + " is traversing !");
											}
										}
										
									}
								},1,1,TimeUnit.SECONDS);
					}
				}

2.LampController类

				/*
				 * 交通灯控制系统，控制灯的状态变化
				 */
				class LampController {
					private Lamp currentLamp;
					public LampController(){
						//刚开始让由南向北的灯变绿;		
						currentLamp = Lamp.S2N;
						currentLamp.light();		
						//每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿	
						ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
						timer.scheduleAtFixedRate(
								new Runnable(){
									public void run(){
										currentLamp = currentLamp.blackOut();
								}
								},10,10,TimeUnit.SECONDS);
					}
				}
				

3.Lamp类

				/*
				 * Lamp对象的描述：每个元素都表示不同方向上的控制灯
				 */  

				enum Lamp {
					S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","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();
						}
						System.out.println(name()+"是绿灯");		
					}
					//将当前灯变为红灯,返回下一个灯
					public Lamp blackOut(){
						this.lighted = false;
						if(opposite != null){
							Lamp.valueOf(opposite).blackOut();
						}		
						//将下一个灯变绿
						Lamp nextLamp= null;
						if(next != null){
							nextLamp = Lamp.valueOf(next);
							System.out.println("绿灯从" + name() + "....转为" + next);			
							nextLamp.light();
						}
						return nextLamp;
					}
				}