黑马程序员之交通灯管理系统

------- android培训、java培训、期待与您交流！ ----------
由于路只有12个方向，所以需要12个方向的灯来分别控制每一条路：

南北灯(直行)，南西灯(左转)，南东灯(右转)

北南灯(直行)，北东灯(左转)，北西灯(右转)

东西灯(直行)， 东南灯(左转)，东北灯(右转)

西东灯(直行)， 西北灯(左转)， 西南灯(右转)

1，Road类

Road类有两个成员变量，一个是路名name，一个是车辆集合vehicles

在Road类的构造方法中，利用线程实现随机增加车辆的方法，并且启动定时器，随时判断能够通过路口。

2，Lamp类

利用枚举实现Lamp类，因为路只有12个方向，所以Lamp类的对象只有12个，分别对应12条路。

Lamp类的构造方法，要传入3个参数，分别为对面的灯opposite，下一个要变绿的灯next，还有一个用于判断当前灯红绿的变量lighted。

Lamp类要有判断当前灯是绿还是红的方法isLighted

Lamp类要有设置当前和对面灯为绿灯的方法light

Lamp类要有设置当前和对象灯为红灯的方法lightOut，并且设为红灯后，要把下一个要变绿的灯next变为绿灯，并且把下一个变绿灯的对面的灯也设置为绿灯。

3，LampController类

LampController类是控制系统，控制多长时间变绿或者变红，所以LampController类要有一个定时器进行定时，固定时间使得不同方向的灯交替变绿

学习心得：通过这个小系统，应该学会面向对象的设计方法，即谁拥有数据，谁就对外提供操作这些数据的方法。

典型案例：

①人在黑板上画圆，可以抽象为几个对象：人，黑板，圆？那么画圆的动作是哪个对象的方法？画圆需要圆心和半径，那么圆心和半径是谁的数据？是圆，所以画圆的方法应该由圆来提供。

②列车司机紧急刹车：有两个对象列车和司机，刹车的方法是谁提供？很明显是列车，因为列车拥有速度、发动机等数据。

③售票员正在统计售货小票的金额：统计金额的方法由售货小票提供。人只是调用了售货小票的方法。

④人把门关上了：关门的方法由门提供。人只是调用了门的关门方法。

⑤路上有很多汽车，路上还要增加新的汽车，还要随时减少汽车：减少汽车的方法由谁提供？由路提供。

⑥两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材做成椅子：对象：石头，石刀，树，木材，椅子。石头可以磨成石刀，那么是石头要提供方法把自己变成石刀？错，把自己变成刀，自己都没了。石头并没有石刀的属性，所以不能提供变成石刀的方法。所以定义一个石刀加工厂，KnifeFactory提供生成石刀的方法。石刀又有砍树的方法，返回木材。同理，椅子加工厂chairFactory提供方法，把木材变成椅子。

⑦球从一根绳子的一端移到了另一端：两个对象：小球、绳子。绳子的本质是为球的移动提供了方向，提供球要滚动到哪一点，所以绳子要提供一个方法nextPoint，返回小球要移动的下一个点。小球的构造方法中，把开始的点和绳子对象传给小球，小球还有移动的方法，调用绳子的方法nextPoint。

交通灯的源代码：
Lamp类：

package 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 boolean lighted;//存储每个Lamp对象中的亮黑状态
private String opposite;//对面的灯
private String next;//下一个要变绿的灯

//	private Lamp(){}

private Lamp(String opposite,String next,boolean lighted){
System.out.println("对面的灯："+opposite+" 下一个绿灯："+next+" 亮灭："+lighted);
this.opposite = opposite;
this.lighted = lighted;
this.next = next;
}

//现在的灯是不是亮的
public boolean isLighted(){
System.out.println(toString()+"是否是绿灯："+lighted);
return lighted;
}
//亮灯，绿灯
public void light(){
this.lighted=true;
System.out.println(toString() + " lamp is green.下面有6个方向的车通过");
//不进行判断会死循环
if(opposite != null){
//获取对面的灯的对象，使其也变亮
Lamp.valueOf(opposite).light();
}
}
//把当前灯变为红灯，并返回要变绿的灯
public Lamp lightOut(){
this.lighted =false;
if(opposite!=null){
Lamp.valueOf(opposite).lightOut();
}
Lamp nextlamp = null;
if(next!=null){
nextlamp=Lamp.valueOf(next);
nextlamp.light();
System.out.println("绿灯从"+ name()+"---->切换为"+ next);
}
return nextlamp;
}
}

灯控制器：LampController

package 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();
//每隔10秒当前灯变黑
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run() {
System.out.println(currentLamp+"即将变为红灯");
currentLamp = currentLamp.lightOut();
}

},
10,
10,
TimeUnit.SECONDS);
}

}

路：Road

package 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 {
//每个Road对象都有一个name成员变量来代表方向，有一个vehicles成员变量来代表方向上的车辆集合
private List<String> vehicles = new ArrayList<String>();
private String name = null;

public Road(String name){
this.name = name;
//jdk1.5的线程库Executors
ExecutorService pool = Executors.newSingleThreadExecutor();
//在Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车
//Runalbe是接口不能直接new，所以这里new了个接口实现类的对象
pool.execute(new Runnable(){
public void run() {
for(int i= 1;i<1000;i++){
try {
//产生1-10之间的随机整数
Thread.sleep((new Random().nextInt(10)+1)*1000);
System.out.println(Road.this.name+"线程到底是个什么东西");
} catch (InterruptedException e) {
e.printStackTrace();
}
//内部类想要访问外部类的局部变量，外部类的局部变量要加上final修饰
//这里也可以访问外部类的成员变量来实现
//访问外部类的成员变量本来可以直接写外部类的成员变量名，
//但是如果这个变量与自己类里的变量名冲突了，要加上类名.this.变量名
vehicles.add(Road.this.name + "_" + i);
System.out.println("牌照为"+Road.this.name + "_" + i + "的车来了");
}

}

});

//在Road对象的构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿，是则将集合中的第一辆车移除掉
ScheduledExecutorService  timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){

public void run() {
if(vehicles.size() > 0){
boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
//布尔型的变量直接用，不用和true去比较了lighted==true
if(lighted){
System.out.println(vehicles.remove(0)+"开走了!");
}
}
}

},
1,
1,
TimeUnit.SECONDS);

}
}

主程序：

package traffic;

public class MainClass {

public static void main(String[] args) {
//创建12条路的对象
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();

}

}