1. Lamp类的编写
package com.isoftstone.interview;
/**
* 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
* 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
* 程序代码只需要控制每组灯中的一个灯即可：
* s2n,n2s
* s2w,n2e
* e2w,w2e
* e2s,w2n
* s2e,n2w
* e2n,w2s
* 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，所以，可以假想它们总是绿灯。
*/
public enum Lamp {
/*每个枚举元素各表示一个方向的控制灯*/
S2N("N2S","S2W",false),S2W("E2N","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),N2W(null,null,true),W2S(null,null,true),E2N(null,null,true);
/*当前灯是否亮着，即是否为绿灯*/
private boolean lighted;
/*与当前灯同时为绿的对应方向*/
private String opposite;
/*当前灯变红时下一个变绿的灯*/
private String next;
//带以上三个参数的构造方法
private Lamp(String opposite, String next,boolean lighted) {
this.opposite = opposite;
this.next = next;
this.lighted = lighted;
}
/**
* 判断是否为绿灯的方法
* @return
*/
public boolean isLighted(){
return lighted;
}
/**
* 某个灯变绿时，它对应方向的灯也要变绿
*/
public void light(){
this.lighted = true;
//如果opposite为null则使改方法死循环，就是一直亮着绿灯
if(opposite != null){
/*valueOf()方法为枚举类自带的方法;把字符串名字传进去返回对应的枚举对象；
* 可能有的人会说为什么不直接把opposite变量定义成枚举Lamp型；
* 这里笔者这么考虑：如果定义成Lamp型，那么上面的S2N这些属性变量
* 里面不方便传值，改成现在这样写，即将opposite定义成String型的，
* 直接给这些属性变量传入一个字符串即可，方便了很多
*/
Lamp.valueOf(opposite).light();
}
System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
}
/**
* 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿
* @return 下一个要变绿的灯
*/
public Lamp blackOut(){
this.lighted = false;
if(opposite != null){
Lamp.valueOf(opposite).blackOut();
}
Lamp nextLamp = null;
if(next != null){
nextLamp = Lamp.valueOf(next);
//name()方法也是枚举类自带的方法，返回一个自身属性名
System.out.println("绿灯从" + name() + "-------->切换为" + next);
nextLamp.light();
}
return nextLamp;
}
}
2. Road类的编写
package com.isoftstone.interview;
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实例对象。
* 每条路线上随机增加新的车辆，增加到一个集合中保存。
* 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
*/
public class Road {
//vehicles代表车俩，是个车俩集合，包括大卡车、小驾车等等所有车俩
List<String> vehicles = new ArrayList<String>();
//name成员变量表示方向
String name = null;
public Road(String name){
this.name = name;
//模拟车辆不断随机上路的过程
/*Executors是jdk5新特性中的执行器，可以这么记：我们起的工具类比如utils都是以s结尾，
* 改类如何用如何拼写必须记住，Executors类似,改类有大量的静态方法；改执行器可以new多种线程池，
* 当然也可以new出下面的单独线程，不管是线程池还是线程都返回一个ExecutorService类型的值
*/
ExecutorService executor = Executors.newSingleThreadExecutor();
//Runnable是接口不能直接new出但是可以将其弄成内部类new出其的实现类
executor.execute(new Runnable() {
@Override
public void run() {
//产生999辆车
for(int i=1;i<1000;i++){
try {
//休息1到10秒随机时间
Thread.sleep((new Random().nextInt(10) + 1) * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
/*内部类访问外部的成员变量可以讲外部类的改成员变量弄错final最终的，
也可以在内部类中使用外部类名.this.外部类变量的方法达到目的*/
vehicles.add(Road.this.name + "_" + i);
}
}
});
//每隔一秒检查对应的灯是否为绿，是则放行一辆车
//定时器（连环爆炸器）的编写，应用相当广泛，必会；new的是Scheduled（调度）调度池
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
//先检查路上有没有车辆
if(vehicles.size()>0){
boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
if(lighted){
//traversing:正在穿过
System.out.println(vehicles.remove(0) + " is traversing !");
}
}
}
},
1, //过多少时间去干这件事
1, //隔多少时间再去干这件事
TimeUnit.SECONDS);//说明上面数值的定量单位，是隔1秒呢还是1分钟或1小时呢;
}
}
3. LampController类的编写
package com.isoftstone.interview;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 车辆控制器，主要操作对象
*/
public class LampController {
private Lamp currentLamp;
public LampController(){
//刚开始让由南向北的灯变绿;
currentLamp = Lamp.S2N;
currentLamp.light();
/*每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿*/
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("车辆有本事你来啊！");
currentLamp = currentLamp.blackOut();
}
},
10,
10,
TimeUnit.SECONDS);
}
}
4. MainClass类的编写
package com.isoftstone.interview;
public class MainClass {
/**
* @param args
*/
public static void main(String[] args) {
/*产生12个方向的路线*/
String[] directions = {"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();
}
}
