本文详细介绍了如何使用面向对象编程设计一个交通灯控制系统，包括Road类用于管理路线、Lamp类用于控制交通灯以及LampController类用于管理灯的状态切换。系统实现了随机车辆生成、绿灯状态变化及车辆通过路口等功能。
面向对象的分析与设计
l 每条路线上都会出多辆车，路线上要随机增加新的车，在灯绿期间，还要每秒钟减少一辆车。
Ø 设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，即系统中总共需要产生12个Road实例对象。
Ø 每条路线上随机增加新的车辆，增加到一个集合中保存。
Ø 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
l 每条路线每隔一秒都会检查控制本路线的灯是否为绿，一个灯由绿变红时，应该将下一方向的灯变绿。
Ø 设计一个Lamp类类表示一个交通灯，每个交通灯都维护一个状态，亮(绿)或不亮(红)，每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。
Ø 总共有12条路线，所以，系统中总共要产生12个交通灯，右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有4个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。
Ø 除了右拐弯方向，其他8条路线的灯，他们是两两相对的，可以归为4组，所以，在编程处理时，只要从这四组中各取出一个灯，对这四个灯依次轮换变亮，与这四个灯方向相对应的灯则之变化，因此，Lamp类中要有一个变量类记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑，每个灯变黑时，都伴随着下一个等的变亮。
² 面向对象的一个重要经验：谁拥有数据，谁就对外提供操作这些数据的方法。
Ø 示例1：
球从一根绳的一端移动到另一端。
代码：
class Rope{
privatePoint start;
private Pointend;
publicPope(Point start,Point end){
this.start = start;
this.end = end;
}
public PointnextPoint(Point currentPoint){
/*通过两点一线的数学公式可以计算出当前点的下一个点。这个细节不属于设计阶段的考虑的问题，如果当前点是终止点，则返回null，如果当前点不是线上的点则抛出异常。*/
}
}
class Ball{
privateRope rope;
private Point currentPoint;
public Ball(Rope rope,Point startPoint){
this.ropr = rope;
this.startPoint = startPoint;
}
publicvoid move(){
currentPoint =rope.nextPoint(currentPoint);
System.out.println(“小球移动了”+currentPoint);
}
}
Ø 示例2：
两块石头磨成一把刀，石刀可以砍树，砍成木材，木材做成椅子。
代码：
StoneKinfe =KnifeFactory.createKinef(stone)
Stone
material = StoneKnife.cut(tree)
tree
Chair = chairFactory.makeChair(material)
material
chair
² 小结：我觉得这种思想，应该像软件工程中提到的：模块化设计。利用这种思想，可以大大降低数据的耦合性，提高数据的可拓展性。
l 思路：
Ø 作图分析：
分析：
从一个路口出去的车辆，可以朝另外三个路口方向驶去，总共有4个这样的路口，那么一个十字路口总共有4*3=12条行驶路线。
为了统一编程模型，可以假设每条路线都有一个红绿灯对其进行控制，右转弯的4条路线的控制灯可以假设成为常绿状态。另外，其他的8条线路是两两成对，可以归为4组，所以，程序只需考虑图中标注了数字号的4条路线的控制灯的切换顺序，这4条路线相反方向的路线的控制灯跟随这4条路线切换，不必额外考虑。
Ø Road类的设计与编码
Road类用来存放每条路线上随机产生的行驶车辆，并在Road类中创建一个检测该方向上的灯是否为绿的方法，绿灯亮时便于将该方向上的车俩移走。
代码如下：
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 {
private List<String>vechicles =new ArrayList<String>();
private Stringname =null;
public Road(String name){
this.name = name;
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(new Runnable(){
public void run() {
for(int i=0;i<1000;i++){
try {
Thread.sleep((new Random().nextInt(10) + 1) * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
vechicles.add(Road.this.name +"_" + i);//匿名内部类访问成员变量：类名.this.成员变量名。
//访问方法内的局部变量：局部变量必须用final修饰。
}
}
});
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
publicvoid run() {
if(vechicles.size()>0){
boolean ligthted =true;
if(ligthted){
System.out.println(vechicles.remove(0) +"is traversing !");
}
}
}
},
1,
1,
TimeUnit.SECONDS);
}
}
Ø Lamp类的编写
在对图分析中，只要控制四个方向的灯，这四个灯相对的灯也就能同时控制，其余的4个右转灯可以不受灯的控制，等效于常绿。具体实现代码如下：
public enum Lamp {
//下面的四个控制灯的先后顺序满足了先直行后左转的要求：直行(S2N)、左转(S2W)、直行(E2W)、左转(E2S)
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(String opposite,String next,boolean lighted){
this.opposite = opposite;
this.next = next;
this.lighted = lighted;
}
//当前灯是否为绿
private boolean lighted;
//与当前灯同时为绿的对应方向
private Stringopposite;
//当前灯变红时下一个变绿的灯
private Stringnext;
public boolean isLighted(){
returnlighted;
}
//某个灯变绿时，它对应方向的灯也要变绿
public void light(){
this.lighted =true;
if(opposite !=null){
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);
System.out.println("绿灯从" + name() +"-------->切换为" +next);
nextLamp.light();
}
return nextLamp;
}
}
Ø LampControler类的编写
定时在规定的时间间隔让当前的绿灯变红，并让下一个方向的灯变绿。代码如下：
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class LampController {
private LampcurrentLamp;
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.blackOut();
}
},
10,
10,
TimeUnit.SECONDS);
}
}
Ø MainClass类设计
代码如下：
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();
}
}
扫一扫
2631
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
