交通灯管理系统
模拟实现十字路口的交通灯管理系统逻辑，需求如下：
1、异步随机生成 按照各个路线行驶的车辆：
例如：
由南向而来去往北向的车辆——执行车辆
由西向而来去往南向的车辆——右转车辆
由东向而来去往南向的车辆——左转车辆
2、信号灯忽略黄灯，只考虑红灯和绿灯。
3、应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。
4、具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。
注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行，直行车辆而后放行左转车辆。
5、每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。
6、随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。
7不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。
思路流程（以从南而来车辆为例）：
1、随机生成从南方向而来的车辆——应当有一个方法，该方法随机生成从南方向而来的车辆。
2、从南方向而来的车辆不止一辆，一个挨一个的队列——应当有一容器，该容器顺序存储南向而来的车辆。
3、车辆到路口，判断信号灯的颜色——有一个方法，用于车辆判断信号灯的颜色。
绿灯右转弯，过路口1秒钟，线程sleep1秒，同时容器中车辆遵从先进先出原则，remove一辆车。
绿灯直行，过路口1秒钟，线程sleep1秒，同时容器中车辆遵从先进先出原则，remove一辆车。
绿灯左转弯，过路口1秒钟，线程sleep1秒，同时容器中车辆遵从先进先出原则，remove一辆车。
红灯右转弯，过路口1秒钟，线程sleep1秒，同时容器中车辆遵从先进先出原则，remove一辆车。
红灯直行等待，红灯变绿灯——有一方法定时控制红绿灯转换
另一方向绿灯变红灯
红灯左转弯等待，红灯变绿灯——有一方法定时控制红绿灯转换
另一方向绿灯变红灯
分析：
1、面向对象分析，分析需求可以分为路线、信号灯、汽车等三个对象。
路线：包括各个方向来往的路线，每一个具体的来往方向视为一个实例对象，线路是有固定数量的，可以考虑用枚举。即，无论哪个路线都应该是路线类的一个具体实例。
信号灯：信号灯只考虑红灯和绿灯，信号灯控制着车辆的停与行。
红灯：直行和左转弯车辆等待，右转弯车辆通行。
绿灯：直行、左转弯和右转弯车辆通行。
另外：两个方向的信号灯永远是一个绿一个红，不能同时出现同一颜色。即，当一个方向的红灯变绿灯时，另一个方向的绿灯同时变为红灯。因此，应该有一个专门用于控制信号灯转换的类。
汽车：汽车在某一线路行驶，没有必要将一辆汽车作为一个专门 的实例对象，只考虑线路问题就可以了。
2、路线，总共有12条线路：南2北、南2东、南2西、东2西、东2北、东2南、北2南、北2西、北2东、西2东、西2南、西2北。每辆车在路口处行驶时都要看信号灯。
右转弯，不受信号灯控制，可以直接通过的为：南2东、东2北、北2西、西2南。——所有右转弯的车辆，我们可以设定其信号灯是永远绿灯，这样所有右转弯的车就直接行驶。
直行， 受信号灯控制 ：南2北和北2南是同样的，东2西和西2东是同样的。
左转弯， 受信号灯控制 ：南2西和北2东是同样的，西2北和东2南是同样的。
Enum Road
{
S2N,S2W,E2W,E2S,//受信号灯控制的路线，共四条
N2S,N2E,W2E,W2N,//该四条线路是与上面四条线路逆向的，受同一信号灯控制
S2E,E2N,N2W,W2S;//右转弯路线，不受信号灯控制，或者说信号灯永远是绿灯
}
3、信号灯，对同一方向的信号灯，只有绿灯和红灯之间的转换，同时，另一方向的信号灯与该线路信号灯对立。
当一个方向的信号灯由绿变红，另一方向信号灯由红变绿。
class Lamp//信号灯类
{
isLight(){}//判断信号灯的红绿状态
light(){}//变绿灯
blackout(){}//变红灯,同时返回下一个 方向的灯
}
class lampController//控制信号灯红绿转换的类
{
lampController()
{
定时转换红绿方法(){}
}
}
4、主要应用
线程池技术：ExecutorService pool = Executors.newSingleThreadExecutor() ; pool.execute(Runnable commend);//生成单个线程，让该线程执行某一动作。
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);timer.scheduledAtFixedRate(arguments);//定时器的使用,一是完成信号灯交替，二是完成车辆过路口动作
枚举：由于方向信号灯是固定的12个，不能再有其他的，因此用枚举，只能选取枚举对象之一。
两个系统：信号灯控制系统，车辆生成与过路口系统，
5、代码实现
package com.itcast.interview.traffic;
public 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);
//构造函数参数表示当前方向的opposite(逆向)，next(下一个方向)，lighted(当前灯状态)
private Lamp(String opposite,String next,boolean lighted)
{
this.opposite = opposite;
this.next = next;
this.lighted = lighted;
}
private String opposite ;
private String next ;
private boolean lighted ;
//返回当前灯状态
public boolean isLighted()
{
return lighted;
}
//让当前灯变绿，同时让逆向的灯也变绿
public void light()
{
this.lighted = true;
if(opposite!=null)
{
Lamp.valueOf(opposite).light();
}
System.out.println(name()+"is green,6 directions followed in total");
}
//让当前灯变红，同时也让逆向灯变红，同时返回下一个变绿的灯
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;
}
}
package com.itcast.interview.traffic;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class LampController
{
//当前信号灯
private Lamp currentLamp;
public LampController()
{
//设定信号灯从S2N开始执行
currentLamp = Lamp.S2N;
//S2N为绿灯，同时对面方向也为绿灯
currentLamp.light();
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable()
{
public void run()
{
//让当前灯变红，同时对面方向的灯也变红，再获取下一个变绿灯信号灯。
//在这里就形成了一种定时循环，达到信号灯红绿定时交替的效果
currentLamp = currentLamp.blackOut();
}
},
10, //当前为绿灯，10后开始执行public void run(){}的内容，即，10秒后开始变红灯
10, //红绿灯交替时间为10秒
TimeUnit.SECONDS//单位时间为秒
);
}
}
package com.itcast.interview.traffic;
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
{
//将生成的汽车存入容器，按FIFO先进先出
List<String> vechicles = new ArrayList<String>();
private String name = null;
//构造函数参数name ，在生成对象时确定了是哪个方向的车辆
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 {
//用sleep(随机时间),随机生成name方向的车辆
Thread.sleep((new Random().nextInt(10)+1)*1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//将生成的车辆添加到容器中
vechicles.add(Road.this.name+i);
}
}
});
//线程池，定时器，连续定时发生过路口的动作
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable()
{
public void run()
{
//需要判定是否有车辆等待过路口，否则出现nullPointException
if(vechicles.size()>0)
{
if(Lamp.valueOf(Road.this.name).isLighted())
{
//List容器remove(0)方法，删除容器第0个元素，并返回删除的该元素，用于表示汽车过路口动作。
System.out.println(vechicles.remove(0)+"----is passing the crossroad");
}
}
}
},
1, //从1秒后开始执行
1, //每隔1秒执行一次
TimeUnit.SECONDS//时间单位：秒
);
}
}
package com.itcast.interview.traffic;
public class MainClass {
/**
* @param args
*/
public static void main(String[] args)
{
//生成12个方向的信号灯，名字注意要与Lamp中元素相符合,以便Lamp.valueOf(opposite)时，获得Lamp的对象。
String[] roadLines = new String[]{"S2N","S2W","S2E","E2S","E2W","E2N","N2E","N2S","N2W","W2N","W2E","W2S"};
for(int i=0;i<12;i++)
{
new Road(roadLines[i]);
}
//启动交通灯控制系统，让信号灯开始工作
new LampController();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
