模拟实现十字路口的交通灯管理系统逻辑，具体需求如下：
异步随机生成按照各个路线行驶的车辆。
例如：
由南向而来去往北向的车辆 ---- 直行车辆
由西向而来去往南向的车辆 ---- 右转车辆
由东向而来去往南向的车辆 ---- 左转车辆
。。。
信号灯忽略黄灯，只考虑红灯和绿灯。
应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。
具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。
注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。
每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。
随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。
不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。
交通管理逻辑示意图
分析：
对象：路，车，红绿灯，红绿灯控制器
车自身不需要方法；
红绿灯(Lamp)：
1.包含红灯和绿灯，由控制器(lampController)来控制变化；
2.红绿灯控制了12个方向的行驶其中右拐的总是能够通行的，不受红灯制约
(南->北，南->西，东->西，东->南，
北->南，北->东，西->东，西->北，
南->东，东->北，北->西，西->南)
(S2N,S2W,E2W,E2S,
N2S,N2E,W2E,W2N,
S2E,E2N,N2W,W2S)
红绿灯的数量不变，使用枚举；
3.由于灯需要点亮（绿灯亮）或者熄灭（红灯亮），故应需要点亮方法(ligth)和熄灭方法(blackOut)；
light方法，灯的状态使用ligthed来标识；需要控制灯的点亮，控制自身的同时也要控制对面的灯(相反方向的红绿灯状态一致,所以相对的方向只需要一个控制方法)，所以需要一个opposite来控制；blackOut方法同上；需要控制下一个方向灯的变化，需要next来控制；
需要判断当前灯的状态，才能决定下一步的动作，所以需要状态的判断方法(isLight);
4.红绿灯控制器（lampController）
需要指定当前灯的状态，需要一个Lamp对象来控制；
定时改变灯的状态，需要定时器来控制变化频率；
路(Road)：
路上有车辆，需要存储车辆的容器，使用ArrayList；
需要产生车辆的方法，在构造函数中实现；
需要定时检查路上是否有车，有车并且是绿灯，则通行，从容器中移除该车辆，并输出结果。
package com.isoftstone.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);// 右拐是不受交通灯控制的，这里设置为右拐的灯总是绿灯
private Lamp() {
}
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) {
// opposite.light();// 同时明灭
// 由于传入的不是对象，而是字符串，因此使用如下方法来改变灯的状态
Lamp.valueOf(opposite).light();// 同时明灭
}
System.out.println(name()+" lamp is green，下面总共可以看到6个方向的灯穿过");
}
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;//返回下一个要变绿的灯，供LampController调用
}
}
package com.isoftstone.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() {
currentLamp = Lamp.S2N;// 指定当前的灯
currentLamp.light();// 设定当前灯的状态为绿灯
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(new Runnable() {// 定时器
public void run() {
System.out.println("即将改变");
currentLamp = currentLamp.blackOut();//控制灯变灭，且把当前灯指向下一个灯
}
}, 10, 10, TimeUnit.SECONDS);
}
}
package com.isoftstone.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 {
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 {
Thread.sleep((new Random().nextInt(10) + 1) * 1000);// 产生车的间隔为1-10秒
} 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) {// 如果灯是绿的，此处不需要ligthed==true，因为lighted本身就是boolean类型
System.out.println(vechicles.remove(0)+" is traversing!");
//vechicles.remove(0)，移除第一个元素，返回的是集合中的元素
}
}
}
}, 1, 1, TimeUnit.SECONDS);// 固定频率调用，这里是1秒
}
}
package com.isoftstone.interview.traffic;
public class MainClass {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// S2N,S2W,E2W,E2S,N2S,N2E,W2E,W2N,S2E,E2N,N2W,W2S
String[] directions = new String[] { "S2N", "S2W", "E2W", "E2S", "N2S",
"N2E", "W2E", "W2N", "S2E", "E2N", "N2W", "W2S" };
for (int i = 0; i < directions.length; i++) {
new Road(directions[i]);
}
new LampController();//产生对象，灯的状态就会改变
}
}
-------------------------------------------------------------------------------
面向对象设计把握一个重要的经验：谁拥有数据，谁就对外提供操作这些数据的方法。
再牢牢掌握几个典型的案例就可以了：
人在黑板上画圆，列车司机紧急刹车，售货员统计收获小票的金额，你把门关上了等。
person,blackboard,circle
draw(){//圆心在圆内，所以画圆的方法就交给圆
x,yàradius；
}
“两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材做成椅子”
/*
* 石头-->(通过KnifeFactory)-->石刀 * 树-->(通过StoneKnife的cut方法)-->木材-->(ChairFactory的makeChair方法)-->椅子 */ StoneKnife = KnifeFactory.createKnife(Stone first,Stone second);//KnifeFactory具有制作石刀的方法(createKnife)，两块石头磨成石刀 material = StoneKnife.cut(tree);//石刀具有砍树的方法 Chair chair = ChairFactory.makeChair(material);//ChairFactory具有制作椅子的方法makeChair
“球从一根绳子的一段移动到了另一端”
class Rope {
private Point start;
private Point end;
public Rope(Point start, Point end) {
this.start = start;
this.end=end;
}
public Point nextPoint(Point currentPoint){
/*
* 通过两点一线的数学公式可以计算出当前点的下一个点，
* 这个细节不属于设计阶段要考虑的问题。
* 如果当前点是终止点，则返回null；如果当前点不是线上的店，则抛出异常。
*/
}
}
class Ball{
private Rope rope;
private Point currentPoint;
public Ball(Rope rope,startPoint){
this.rope=rope;
this.currentPoint=startPoint;
}
public void move(){
currentPoint=rope.nextPoint(currentPoint);
System.out.println("小球移动到了"+currentPoint);
}
}