java面试项目<交通灯管理系统>

<交通灯管理系统>

项目的需求：

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

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

例如：

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

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

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

       。。。

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

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

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

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

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

 

通过上述分析：我们通过画图去分析：

分析可知，对于这个十字路口来说，总共有12条路线，右4条路线，（S2E，E2N,N2W,W2S）的信号灯永远为绿色，因为右转没有限制（为统一编程模型，可以假定其向右转也有信号灯控制）。

而对于直行来说，南到北和北到南是同一种状态，其他也是，所以，剩余的八条线路是两两成对的。可以归为4组。

也就是说当在控制南到北为红灯时候，北到南也为红。

另外：当信号灯在四条马路上来回切换的时候，仅仅只有四条在切换。其他四条跟着成对的那个进行。

也就是只控制南到北，南到西，东到西，东到南这四个灯的来回切换即可

 

初步设想一下有哪些对象：灯，对于灯的切换的控制系统，汽车，路线，汽车看到自己所对应路线上是否为绿灯，并且应该看其前边是否有车。怎么才能确定前边是否有车呢，应该问车所在的路对对应的对象。路中有增加和删除车的方法。再看题目，我们这里并不要体现车辆移动的过程，只是捕捉出车辆穿过路口的过程，也就是捕捉路上减少一辆车的过程，所以，这个车并不需要单独设计成为一个对象，用一个字符串表示就可以了。

所以：在这里我们开始去定义对象，并逐步完善。

我们使用点亮为绿色，关闭为红色

首先定义路线：

[java]  view plain copy

1. //省略了import  
2.   
3. public class Load  
4.   
5. {  
6.   
7.     private String name;//对应路线的名字  
8.   
9.     List<String> list = new ArrayList<String>();//存储车的集合  
10.   
11.     public Load(String name)  
12.   
13.     {  
14.   
15.     this.name =name;  
16.   
17. //在创建一条路的同时，去向这个路中加入车辆，也就是另外开辟一个线程，用来给这//条路增加车辆。  
18.   
19.     ExecutorService es = Executors.newSingleThreadExecutor();  
20.   
21.     es.execute(new Runnable(){  
22.   
23.     public void run()  
24.   
25.     {  
26.   
27.         for(int i=0;i<100;i++)  
28.   
29.         {  
30.   
31.        list.add(i+"");  
32.   
33.        try  
34.   
35.        {  
36.   
37.         Thread.sleep(1000);  
38.   
39.        }  
40.   
41.        catch(Exception e)  
42.        {  
43.           e.printStackTrace();  
44.        }  
45.         }  
46.     }  
47.   
48.     });  
49.   
50. //在增加完车辆之后，就要在每隔一定时间，去让路检查自己所对应的灯是否为绿色，  
51.   
52. //如果为绿色，则让路上的车开始走。     
53.   
54. ScheduledExecutorService  ses = Executors.newScheduledThreadPool(1);  
55.   
56.      
57.   
58. //定义了一个定时器。  
59.   
60.     ses.scheduleAtFixedRate(new Runnable(){  
61.   
62.         public void run(){  
63.   
64.        if(/*这里需要去调用这个路所对应的灯的方法，去判断灯的颜色，如果为绿，则去让路上的第一个车移动*/)  
65.   
66.        {  
67.   
68.           String move = list.remove(0);  
69.   
70.           System.out.println(Load.this.name+"。。路上的车"+move+"被移走");  
71.   
72.        }  
73.   
74.         }  
75.   
76.     },1,2,TimeUnit.SECONDS);  
77.   
78.     }  
79.   
80. }  
81. 
    

定义完了路，我们就要定义灯了。根据题意，我们使用枚举类型去定义灯。

[java]  view plain copy

1. package test;  
2.   
3. public enum Lamp  
4.   
5. {  
6.   
7. //我们考虑到，一个灯有三个相关联的参数，所对应的灯（状态一起变化的灯），这个灯变化之后的下一个灯。（也就是下一个状态变化的灯）。这个灯的状态（红或者绿）。  
8.   
9. S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),  
10.   
11.     N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),  
12.   S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);  
13.   
14. //初始的时候，将所有右转弯的灯都为绿色（开启状态（true））。    
15.   
16.     private boolean lighted;//其状态  
17.   
18.     private String opposite;//其相反的对应的灯。  
19.   
20.     private String next;//下一个状态改变的灯  
21.   
22.     public boolean isLighted()  
23.   
24.     {//判断是否为开启（也就是绿灯或者红灯）  
25.   
26.     return this.lighted;  
27.   
28.     }  
29.   
30.      private Lamp(String opposite,String next,boolean lighted)  
31.   
32.      {  
33.   
34.      this.opposite=  opposite;  
35.   
36.      this.next =next;  
37.   
38.      this.lighted =lighted;  
39.   
40.      }  
41.   
42.      public void light()//将灯由红变绿，也就是开启状态。  
43.   
44.      {  
45.   
46.      this.lighted = true;  
47.   
48.      System.out.println(this.name()+"的灯变成绿色");  
49.   
50.      if(opposite!=null)  
51.   
52.      {//由于相同组的灯何其上边的状态一致。所以将一个灯的状态改变时候，其相同组的灯也需要改变。  
53.   
54.         Lamp.valueOf(opposite).light();  
55.   
56.      }  
57.   
58.      }  
59.   
60.      public LampClose()  
61.   
62.      {  
63.   
64. //与light()方法类似。在变成红灯的同时，将其同组的灯变成红灯，然后将下一组灯的颜色变成绿色。  
65.   
66.      this.lighted = false;  
67.   
68.      if(opposite!=null)  
69.   
70.      {  
71.   
72.         Lamp.valueOf(opposite).Close();     
73.   
74.      }  
75.   
76.    
77.   
78.      Lamplamp = null;  
79.   
80.      if(next!=null)  
81.   
82.      {  
83.   
84.         lamp = Lamp.valueOf(next);  
85.   
86.           
87.   
88.         lamp.light();  
89.   
90.      }  
91.   
92.      return lamp;//这里返回下一个灯的原因是在控制器中，每次关闭的都是当前为绿色的灯。所以在一个绿灯变成红灯的时候，要将下一个变成绿灯的灯返回，一遍再次对这个绿灯进行改变。  
93.   
94.        
95.   
96.      }  
97.   
98.    
99.   
100. }  

控制器类的编写：用于控制各个灯的开关，（也就是变红和变绿）

[java]  view plain copy

1. public class Controller  
2.   
3. {  
4.   
5.     private Lamp thisTimeLamp;//当前被控制的灯。  
6.   
7.     public  Controller()  
8.   
9.     {  
10.   
11.     thisTimeLamp =Lamp.S2N;//当前指向的灯为从南到北的灯。  
12.   
13.     thisTimeLamp.light();      //使其变成绿色。  
14.   
15.     ScheduledExecutorService es = Executors.newScheduledThreadPool(1);     
16.     es.scheduleAtFixedRate(newRunnable(){  
17.   
18.         public void run()  
19.   
20.         {//每隔一定的时间，就将当前的灯变成红灯（关闭）。而在关闭方法中，又将下一个绿灯返回。依次重复。  
21.   
22.        thisTimeLamp = thisTimeLamp.Close();  
23.   
24.        }     
25.   
26.     },1,3,TimeUnit.SECONDS);  
27.   
28.     }  
29.   
30. }