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

-------
android培训、java培训、期待与您交流！ ----------

交通灯管理系统

模拟实现十字路口的交通灯管理系统逻辑，具体需求如下：

异步随机生成按照各个路线行驶的车辆。

例如：

       由南向而来去往北向的车辆 ---- 直行车辆

       由西向而来去往南向的车辆 ---- 右转车辆

       由东向而来去往南向的车辆 ---- 左转车辆

       。。。

信号灯忽略黄灯，只考虑红灯和绿灯。

应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。

具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。

注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。

随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

图解：



分析：
1.车辆穿过的方向总共有12个，相当于有12条路线。路线上在随机时间内增加车辆，并且在绿灯期间每秒钟放行一辆车。
2.每条路线对应一个信号灯，总共有且只有12个灯。信号灯有两种状态，分别是绿灯和红灯。信号灯有变绿和变红以及判断当前状态3个方法。
3.信号灯控制器是用来以固定频率切换信号灯的状态，从而操作整个系统运转。

思路：
1.需要创建3中对象，分别是Road对象，Lamp对象以及LampController对象。
2.Road对象共有12个，对象中自有一个集合，在对象产生后，用来在随机时间内增加车辆到集合中以及每隔1秒判断当前方向的信号灯是否为绿灯，如果是则移除集合中第一位的车辆。
3.Lamp对象是固定的，因此可以设置成枚举类，枚举的常量为12个，对应12个方向的路线。但主要考虑S2N,S2W,E2W,E2S四个方向上灯的变化。因为其对应的相反四个方向的灯的变红是相同的，另外4个方向都是右转方向，直接当做常绿考虑即可。灯的变绿方法中，当前灯变绿，同时使相反方向的灯也变绿。同样，变红方法中，当前和相反方向的灯都变红，并且让当前灯的下一个灯变绿。
4.LampController对象中主要操作一个定时器来以固定频率(每隔10秒)操作当前信号灯的红绿切换，使当前灯变红，下一个灯变绿，使整个系统运转起来。
5.MainClass类创建12个Road对象，然后获得LampController对象，使程序启动。

代码：
Road类：

package com.itheima;

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个方向。
* Road对象就如同一个容器，存储着车辆元素，随机增加车辆可以看作是往容器中存储元素。
* 而车辆通过则可以看作是容器remove元素。
*/
public class Road {
/*内部定义一个集合容器，存储车辆*/
private List<String> vehicles = new ArrayList<String>();

private String name;
public Road(String name){
this.name = name;
/*创建一个线程，用来随机生成车辆*/
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(new Runnable(){
public void run(){
for(int i=1;i<100;i++){//每个方向总共生成99辆车
try {
/*在1-10秒内随机生成一辆车*/
Thread.sleep((new Random().nextInt(10)+1)*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
/*以路的方向+编号来定义一辆车*/
vehicles.add(Road.this.name+"-"+i);
}
}
});
/*创建一个定时器，每隔一秒，只要Road对象对应方向的灯是绿灯，车辆就通过一辆*/
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run(){
/*判断该Road对象对应方向的灯是否为绿灯*/
boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
if(lighted){
if(vehicles.size()>0)//确定容器内有元素，然后移除最前面的元素，即车辆通过
System.out.println(vehicles.remove(0)+" is passing through!");
}
}
},
1,
1,
TimeUnit.SECONDS
);
}

}

Lamp类：

package com.itheima;

/**
* Lamp对象代表每个方向上的灯，总共有12个方向。因为灯从一开始就有且只有12个。故用枚举类描述。
* 12个灯中有4个右转的灯没有限制，可以考虑是常绿的。另外8个灯中都是一一对应的，因此只考虑4个灯，其余4个灯的与之都是对应的。
* 这个4个灯分别为S2N,S2W,E2W,E2S,对应的4个灯为N2S,N2E,W2E,W2N.常绿的灯为S2E,E2N,N2W,W2S.
* 灯的属性分别有是否为绿灯，对应的相反的灯，以及下一个灯。
*/
public enum Lamp {
/*主要操作的四个灯，对应的属性分别是 相反的灯、下一个灯、以及初始为红灯*/
S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
/*主要的灯对应的四个灯，相反的灯和下一个灯都是null，初始为红灯*/
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;
/*相反和下一个灯的属性定义成String类，可以通过枚举的valueOf方法获取其对应的灯对象*/
/*不能定义成Lamp类，因为初始化时会出现相反和下一个灯尚未定义的问题*/
private String opposite;
private String next;
/*枚举的构造函数必须是私有的*/
private Lamp(String opposite,String next,boolean lighted){
this.opposite = opposite;
this.next = next;
this.lighted = lighted;
}
public boolean isLighted(){//判断是否为绿灯
return lighted;
}
/*使灯变绿*/
public void light(){
this.lighted = true;
System.out.println(name()+"  is green! 下面总共会有六个方向会有车辆通过！");
if(opposite!=null)//如果相反方向的灯不为空，也使其变绿
Lamp.valueOf(opposite).light();
}
/*使灯变红*/
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;//变红的函数返回值类型为Lamp类，返回下一个灯，方便控制器操作
}
}

LampController类：

package com.itheima;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 控制器主要用来控制灯的变化，从绿到红的变化。
* 因为灯的跳转是固定频率的，所以用定时器，，每隔10秒跳转一次。
* 直接在构造函数里描述，对象已建立，就会自动运行。
*/
public class LampController {
/*定义一个当前灯，通过当前灯的变化来运转整个系统*/
private Lamp currentLamp;

LampController(){
/*初始化默认当前灯是 S2N,且为绿灯*/
this.currentLamp = Lamp.S2N;
currentLamp.light();

ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run(){
/*每隔10秒当前灯变红 ，下一个灯变绿。通过blackOut方法返回下一个灯，并赋给当前灯。*/
currentLamp  = currentLamp.blackOut();
}
},
10,
10,
TimeUnit.SECONDS

a94b
);
}
}

MainClass：

package com.itheima;

public class MainClass {

/**
* 主函数，生成对象，启动系统。
*/
public static void main(String[] args) {
/*首先生成12个方向上路的对象*/
String[] roadDirections = new String[]{
"S2N","S2W","E2W","E2S",
"N2S","N2E","W2E","W2N",
"S2E","E2N","N2W","W2S"
};
for(int i=0;i<roadDirections.length;i++){
new Road(roadDirections[i]);
}
/*生成控制器对象，启动系统*/
new LampController();
}

}

总结：
1.在一个系统中，需要运用面向对象的思想分析每个对象以及各个方法的所属关系。通过明确所需对象以及其方法，完善整个设计思路。在交通灯项目中，
分析的对象应该有路，车辆，信号灯，控制器，但因为不考虑车辆的具体行为，因此可以把路设置成一个容器，而车辆作为其中的元素来存储和移除。这样
系统需要操作的对象就只有3个。明确对象和具体行为时，更加要理清对象与对象之间的关系。因为面向对象的思想就是在产生对象，使用对象和维护对象。
2.虽然整个项目中思想更为重要，但在代码的书写时，需要对每个部分准确的书写，要注重细节。往往一个小的问题，可以让后期的调试非常困难。
特别在Lamp类的描述中，对于信号灯的方法描述时尤其需要注意，变绿和变红时，相反的灯也要变化，且变红时，要使下一个灯变绿，这样才能维持整个
系统的运转。另外在12个方法的书写时，也要格外小心，一个字母的错误，可能导致运行时没有异常，但信号灯切换数次后就不切换的现象。
3.对于定时器的应用，以后在项目中应该也是非常常用。对于固定频率产生的行为，要记得使用定时器。另外产生线程的新方法较传统的方法更加灵活，可以多加使用。