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

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

交通灯管理系统:

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

例如：       

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

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

。。。

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

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

具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。 注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

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

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

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

 

画图分析：

 

交通灯管理系统涉及到的对象：

路灯控制系统，汽车，路线

路中存储着车辆的集合，显然路上就应该有增加车辆和减少车辆的方法了。

我们这里并不要体现车辆移动的过程，只是捕捉出车辆穿过路口的过程，

也就是捕捉路上减少一辆车的过程，所以，这个车并不需要单独设计成为一个对象，用一个字符串表示就可以了。

每条路线上都会出现多辆车，路线上要随机增加新的车，在灯绿期间还要每秒钟减少一辆车。

（1）设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。

（2)   每条路线上随机增加新的车辆，增加到一个集合中保存。

（3)   每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。

 对红绿灯和红绿灯控制系统两个对象的进行分析：

每条路线每隔一秒都会检查控制本路线的灯是否为绿，一个灯由绿变红时，应该将下一个方向的灯变绿。

（1)设计一个Lamp类来表示一个交通灯，每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。

（2)总共有12条路线，所以，系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。

（3)除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯。

（4)无论在程序的什么地方去获得某个方向的灯时，每次获得的都是同一个实例对象，所以Lamp类改用枚举来做显然具有很大的方便性，永远都只有代表12个方向的灯的实例对象。

（5)设计一个LampController类，它定时让当前的绿灯变红。

 

 

编写Road类

每个Road对象有一个vehicles成员变量来代表方向上的车辆集合，都有一个name成员变量来代表方向。
在Road对象的构造方法中创建线程池，启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车（用一个“路线名_id”形式的字符串进行表示）。
在Road对象的构造方法中启动一个定时器，每隔一秒检查该方向上的灯是否为绿，是则打印车辆集合和将集合中的第一辆车移除掉。

 

[java]  view plain copy

1. package com.itheima.traffic;  
2.   
3. import java.util.ArrayList;      
4. import java.util.List;      
5. import java.util.Random;      
6. import java.util.concurrent.ExecutorService;      
7. import java.util.concurrent.Executors;      
8. import java.util.concurrent.ScheduledExecutorService;      
9. import java.util.concurrent.TimeUnit;      
10.     /**   
11.      * 每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。   
12.      * 每条路线上随机增加新的车辆，增加到一个集合中保存。   
13.      * 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。  
14.      */     
15. public class Road {      
16.     //用面向接口的方式，定义一个集合，用来存储和操作车辆这个字符串对象      
17.     private List<String> vechicles=new ArrayList<String>();      
18.     //定义路线名变量      
19.     private String name;      
20.     public Road(String name){      
21.         this.name=name;      
22.                
23.         //模拟车辆不断随机上路的过程，使用线程池产生单个线程的方法，创建一个线程池  
24.         ExecutorService pool=Executors.newSingleThreadExecutor();  
25.         //调用execute方法，可向线程池提交一个任务，让池中的线程执行任务。实现类        
26.     pool.execute(new Runnable(){      
27.         //复写run方法，需要执行的代码，随机产生车辆，并存入集合      
28.     public void run() {      
29.         for (int i = 1; i <1000; i++) {      
30.             try {      
31.                   //1到10秒内随机产生一辆车      
32.                   Thread.sleep((new Random().nextInt(10)+1)*1000);      
33.             } catch (InterruptedException e) {                                 
34.                         e.printStackTrace();      
35.             }      
36.             //车辆进入路线中 .访问外部类成员变量    
37.             vechicles.add(Road.this.name+"_"+i);      
38.             }      
39.         }      
40.     });      
41.     //定义一个定时器，每隔一秒检查对应的灯是否为绿，是则放行一辆车      
42.     ScheduledExecutorService timer=Executors.newScheduledThreadPool(1);      
43.     timer.scheduleAtFixedRate(      
44.     new Runnable() {      
45.     //定时器要执行的代码      
46.             public void run() {      
47.            //判断该路线中是否有车，有则进行放行操作      
48.             if (vechicles.size()>0) {      
49.             //如果该路线上对应的灯是绿色的，则放行车辆      
50.             boolean lighted=Lamp.valueOf(Road.this.name).isLighted();      
51.             if(lighted){      
52.         //移走第一辆车  
53.                     System.out.println(vechicles.remove(0)+"\tis traversing!");      
54.                    }      
55.                }       
56.            }      
57.   
58.            },       
59.            1,//隔多少秒执行      
60.            1,//周期      
61.            TimeUnit.SECONDS/*时间单位*/);         
62.     }      
63. }  
64.    

 

 

编写Lamp类

1，系统中有12个方向上的灯，在程序的其他地方要根据灯的名称就可以获得对应的灯的实例对象，综合这些因素，将Lamp类用java5中的枚举形式定义更为简单。

2，每个Lamp对象中的亮黑状态用lighted变量表示，选用S2N、S2W、E2W、E2N这四个方向上的Lamp对象依次轮询变亮，Lamp对象中还要有一个oppositeLampName变量来表示它们相反方向的灯，再用一个nextLampName变量来表示此灯变亮后的下一个变亮的灯。这三个变量用构造方法的形式进行赋值，因为枚举元素必须在定义之后引用，所以无法再构造方法中彼此相互引用，所以，相反方向和下一个方向的灯用字符串形式表示。

3，增加让Lamp变亮和变黑的方法：light和blackOut，对于S2N、S2W、E2W、E2N这四个方向上的Lamp对象，这两个方法内部要让相反方向的灯随之变亮和变黑。blackOut方法还要让下一个灯变亮。

4，除了S2N、S2W、E2W、E2N这四个方向上的Lamp对象之外，其他方向上的Lamp对象的nextLampName和oppositeLampName属性设置为null即可，并且S2N、S2W、E2W、E2N这四个方向上的Lamp对象的nextLampName和oppositeLampName属性必须设置为null，以便防止light和blackOut进入死循环。

 

[java]  view plain copy

1. package com.itheima.traffic;  
2.       
3.     /**   
4.      * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。   
5.      * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，   
6.      * 程序代码只需要控制每组灯中的一个灯即可：   
7.      * s2n,n2s       
8.      * s2w,n2e   
9.      * e2w,w2e   
10.      * e2s,w2n   
11.      * s2e,n2w   
12.      * e2n,w2s   
13.      * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，   
14.      * 所以，可以假想它们总是绿灯。   
15.      */      
16.     public enum Lamp {      
17.   
18.     //每个枚举元素各表示一个方向上的控制灯     
19.    S2N(false,"N2S","S2W"),S2W(false,"N2E","E2W"),E2W(false,"W2E","E2S"),E2S(false,"W2N","S2N"),      
20.   
21.     //下面元素表示与上面的元素的相反方向的灯，它们的“反方向灯”和“下一个灯”忽略  
22.     N2S(false,null,null),N2E(false,null,null),W2E(false,null,null),W2N(false,null,null),      
23.   
24.     //下面元素表示四个右转弯方向的灯，因为其不受红绿灯控制，所以可以假设总是绿灯    
25.     S2E(true,null,null),E2N(true,null,null),N2W(true,null,null),W2S(true,null,null);      
26.           
27.     //当前灯的状态，是否为绿      
28.     private boolean lighted;      
29.     //当前灯变红时，下个绿的灯      
30.     private String next;      
31.     //与当前灯相反方向的同为绿的灯      
32.     private String opposite;      
33.     //构造函数      
34.     private Lamp(boolean lighted,String opposite,String next){      
35.         this.lighted=lighted;      
36.         this.next=next;      
37.         this.opposite=opposite;      
38.     }      
39.     //提供一个判断是否为亮（绿）的方法      
40.     public boolean isLighted(){      
41.         return lighted;      
42.     }      
43.     //某个灯变绿时，它对应方向的灯也要变绿    
44.      public void light(){      
45.         this.lighted=true;      
46.         //为造成死循环，只将一方拥有反方向的灯      
47.         if (opposite!=null) {      
48.             //将对应的反方向的灯变绿      
49.             Lamp.valueOf(opposite).light();      
50.         }      
51.         System.out.println(name()+"Lamp is green 下面将能看到六个方向的车辆通过。 ");      
52.     }      
53.      //某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿    
54.        public Lamp blackout(){      
55.         //当前灯变红，对应方向的灯也变红      
56.         this.lighted=false;      
57.         if(opposite!=null){      
58.             Lamp.valueOf(opposite).blackout();                
59.      }      
60.         //当前灯变红的同时，将下一个灯变绿      
61.         //将下一个变绿的灯返回      
62.         Lamp nextLamp=null;      
63.         if (next!=null) {      
64.             nextLamp=Lamp.valueOf(next);      
65.             System.out.println("绿灯从"+name()+"——>切换为"+next);      
66.             nextLamp.light();      
67.         }      
68.         return nextLamp;      
69.     }      
70. }       

 

编写LampController类：

交通灯控制器

1，LampController构造方法中要设定第一个为绿的灯，要指定当前灯为绿状态，以S2N作为第一个

2，LampController对象的start方法中将当前灯变绿，然后启动一个定时器，每隔10秒将当前灯变红和将下一个灯变绿。

[java]  view plain copy

1. package com.itheima.traffic;  
2.   
3. import java.util.concurrent.Executors;      
4. import java.util.concurrent.ScheduledExecutorService;      
5. import java.util.concurrent.TimeUnit;      
6.     /**   
7.      * 红绿灯控制系统用来控制红绿灯的切换时间   
8.      * 每隔10秒将当前灯变红，并按顺序将下一个方向的灯变绿   
9.      */     
10.   
11. public class LampController {      
12.     //定义当前灯为第一个绿的灯      
13.     private Lamp currentLamp;      
14.     public LampController(){      
15.        //刚开始让由南向北的灯变绿      
16.         currentLamp = Lamp.S2N;      
17.         currentLamp.light();      
18.   
19.         //定义一个定时器，每隔10秒就将当前灯由绿变红，并将下一个灯变绿      
20.         ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);      
21.         timer.scheduleAtFixedRate(      
22.                 new Runnable() {      
23.                     public void run() {      
24.                         //将下一个灯切换为当前的灯      
25.                         currentLamp = currentLamp.blackout();      
26.                         System.out.println("灯变了");      
27.                     }      
28.                 },      
29.                 10,      
30.                 10,       
31.                 TimeUnit.SECONDS);      
32.     }      
33. }      

编写MainClass类
1，用for循环创建出代表12条路线的对象。
2，创建红绿灯控制系统对象

[html]  view plain copy

1. package com.itheima.traffic;  
2.   
3. public class MainClass {      
4.     public static void main(String[] args){    
5.       
6.     String[] directions = {"S2N","S2W","E2W","E2S",  
7.             "N2S","N2E","W2E","W2N",  
8.             "S2E","E2N","N2W","W2S"};        
9.   
10.         for (int i = 0; i < directions.length; i++) {      
11.             new Road(directions[i]);      
12.         }      
13.         // 生成交通灯系统并运行         
14.         new LampController();      
15.     }      
16. }  

 

 心得：

从交通灯管理系统中，看似很复杂的内容，但是经过老师的讲解变得很简单、很好理解。我学到了如何用面向对象的思考方式来编程，尤其张老师讲的几个例子十分鲜明、有特色，通过提取类中的数据，数据在什么上就定义成这个类上的内容。让我认识到，拥有好的逻辑思维和面向对象编程的思想才是编程最重要的地方！以后会注重培养自己这方面的能力。