1. //东南西北(North South East West)
   
2. 
   
3. package com.isoftstone.interview.traffic;
   
4. 
   
5. public enum Lamp {
   
6.         N_E(new Road("东》》西路")),N_S(new Road("东》》南路")),E_N(new Road("西》》东路")),E_W(new Road("西》》北路")),
   
7.         N_W(new Road("东》》南路")),E_S(new Road("西》》南路")),
   
8.         S_W(new Road("南》》北路")),S_E(new Road("南》》西路")),W_S(new Road("北》》南路")),W_N(new Road("北》》东路")),
   
9.         W_E(new Road("北》》西路")),S_N(new Road("西》》东路"));
   
10.        
    
11.         private boolean islight=false;
    
12.         private Road road;
    
13.        
    
14.         //
    
15.         Lamp(Road road){
    
16.                 this.road = road;
    
17.         }
    
18.        
    
19.         //判断灯是否亮着，
    
20.         private boolean isLight(){
    
21.                 return islight;
    
22.         }       
    
23.         public void setLamp(boolean islight){
    
24.                 this.islight = islight;
    
25.                
    
26.                 //如果灯亮  则呼叫本路车通过
    
27.                 if(islight){
    
28.                         callCar();
    
29.                 }
    
30.                 else{
    
31.                         System.out.println(this.road.name+"~~~~~~~~~~~~~~~~~~~禁止通行");
    
32.                 }
    
33.         }
    
34.         private void callCar(){
    
35.                 System.out.println("***"+this.road.name+"*******可以通车");
    
36.                 this.road.work();
    
37.                
    
38.         }
    
39. }
    

复制代码

功能： 交通灯，黑马学仔都懂得
　　
　　思路：
　　交通灯控制台LampContral｛
　　控制各路Lamp的亮灭｛
　　If（亮）｛
　　呼叫对应的Road.work()让车辆通行
　　｝
　　else
　　｝
　　｝
　　
　　
　　此方法的特点在于，灯亮了就呼叫对应路上的车辆通行，不用车辆监视着灯的状态
　　
　　代码粗糙，很多地方没有优化，大家凑合着看吧！

1. package com.isoftstone.interview.traffic;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class Road {
   
6.        
   
7.         private static int num=0;
   
8.         //名字
   
9.         public String name=null;
   
10.         //排队中的车辆
    
11.         //private List<String> listCar = new ArrayList<String>();
    
12.         private int listCar = 0;
    
13.        
    
14.         Road(String name){
    
15.                 this.name=name;
    
16.         //        addCar();
    
17.                 new Thread(new Runnable(){
    
18. 
    
19.                                                 @Override
    
20.                                                 public void run() {
    
21.                                                         // 一到十秒随机加入一辆车
    
22.                                                         try {
    
23.                                                                         Thread.sleep((new Random().nextInt(10)+1)*1000);
    
24.                                                                 } catch (Exception e) {
    
25.                                                                         // TODO Auto-generated catch block
    
26.                                                                         e.printStackTrace();
    
27.                                                                 }
    
28.                                                                 //listCar.add(Road.this.name+":");
    
29.                                                                 listCar++;
    
30.                                                                 System.out.println("添加一辆车>>>>>>>"+Road.this.name);
    
31.                                                         }
    
32.                                                        
    
33.                                        
    
34.                                                
    
35.                                         }).start();
    
36. 
    
37.                
    
38.         }
    
39.        
    
40.         //每秒通过一辆车
    
41.         public void work(){
    
42.                 new Thread(new Runnable(){
    
43. 
    
44.                         @Override
    
45.                         public void run() {
    
46.                                 // TODO Auto-generated method stub
    
47.                                 //if(listCar.isEmpty()){
    
48.                                 if(listCar==0){
    
49.                                         //这路木有车
    
50.                                         System.out.println(Road.this.name+"······························木有车");
    
51.                                 }
    
52.                                 else{
    
53.                                         try {
    
54.                                                 Thread.sleep(1000);
    
55.                                         } catch (InterruptedException e) {
    
56.                                                 // TODO Auto-generated catch block
    
57.                                                 e.printStackTrace();
    
58.                                         }
    
59.                                         listCar--;
    
60.                                         System.out.println("__________________________________"+Road.this.name+">>>>>>>>>>>>>>>>>通过一辆车");
    
61.                                 }
    
62.                         }
    
63.                        
    
64.                 }).start();
    
65.         }
    
66. }
    

复制代码

1. /*
   
2. * 功能：
   
3. * 控制交通灯，十秒钟变换一次
   
4. * */
   
5. 
   
6. package com.isoftstone.interview.traffic;
   
7. 
   
8. import java.util.Random;
   
9. 
   
10. public class LampContral {
    
11.         //创建十二盏灯
    
12.         private Lamp[] lamps = {
    
13.                                                         Lamp.N_E,Lamp.N_S,Lamp.E_N,Lamp.E_W,Lamp.
    
14.                                                         N_W,Lamp.E_S,
    
15.                                                         Lamp.S_W,Lamp.S_E,Lamp.W_S,Lamp.W_N,
    
16.                                                         Lamp.W_E,Lamp.S_N
    
17.                                               };
    
18.         LampContral(){
    
19.                 // 初始化灯 全部置为 红
    
20.                 for(Lamp lamp:lamps){
    
21.                         lamp.setLamp(false);
    
22.                 }
    
23.         }
    
24.         public void work()throws Exception{
    
25.                
    
26.                 while(true){
    
27.                         for(int i=0; i<4; i++){
    
28.                                 lamps[i].setLamp(true);
    
29.                         }
    
30.                                         //sleep
    
31.                         Thread.sleep(10000);
    
32.                                         for(int i=0; i<4; i++){
    
33.                                                 lamps[i].setLamp(false);
    
34.                                         }
    
35.                         for(int i=4;i<6; i++){
    
36.                                 lamps[i].setLamp(true);
    
37.                         }
    
38.                                         //sleep
    
39.                         Thread.sleep(10000);
    
40.                                         for(int i=4;i<6; i++){
    
41.                                                 lamps[i].setLamp(false);
    
42.                                         }
    
43.                         for(int i=6;i<10; i++){
    
44.                                 lamps[i].setLamp(true);
    
45.                         }
    
46.                                         //sleep
    
47.                         Thread.sleep(10000);
    
48.                                         for(int i=6;i<10; i++){
    
49.                                                 lamps[i].setLamp(false);
    
50.                                         }
    
51.                         for(int i=10;i<12; i++){
    
52.                                 lamps[i].setLamp(true);
    
53.                         }
    
54.                                         //sleep
    
55.                         Thread.sleep(10000);
    
56.                                         for(int i=10;i<12; i++){
    
57.                                                 lamps[i].setLamp(false);
    
58.                                         }               
    
59.                 }
    
60.         }
    
61.        
    
62. }
    

复制代码

1. package com.isoftstone.interview.traffic;
   
2. 
   
3. public class Controlcentre {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args)throws Exception {
   
9.                 // TODO Auto-generated method stub
   
10.                 new LampContral().work();
    
11.         }
    
12. 
    
13. }
    

复制代码

心凉了~  

郭宁 发表于 2012-6-4 12:44
心凉了~

lz能具体说说和张老师的思想不同在哪里么？

额，你这个跟张老师的区别，应该是没有区别，并且你这个如果按照面向对象的观点来看，不太合理，假如你自己开着车，到路口，应该是你判断灯，开车走，而不是灯叫你走。。。。

我看了一下，  ，    我说说，     你的一个时刻同时有四个方向可以通车？？ D:\1.bmp  这是什么意思啊？   不是只有当南往北的灯变红后，才能有南往西的么？

***南》》北路*******可以通车
***南》》西路*******可以通车
***北》》南路*******可以通车
***北》》东路*******可以通车
__________________________________南》》西路>>>>>>>>>>>>>>>>>通过一辆车
__________________________________南》》北路>>>>>>>>>>>>>>>>>通过一辆车
__________________________________北》》南路>>>>>>>>>>>>>>>>>通过一辆车
__________________________________北》》东路>>>>>>>>>>>>>>>>>通过一辆车

杜俊彪 发表于 2012-6-4 20:01
***南》》北路*******可以通车
***南》》西路*******可以通车
***北》》南路*******可以通车

1. private Lamp[] lamps = {
   
2.                                                         Lamp.N_E,Lamp.N_W,Lamp.E_N,Lamp.E_S,Lamp.
   
3.                                                         N_S,Lamp.E_W,
   
4.                                                         Lamp.S_W,Lamp.S_N,Lamp.W_S,Lamp.W_E,
   
5.                                                         Lamp.W_N,Lamp.S_E
   
6.                                               };

复制代码

谢谢提醒：灯和路的名字没有对应好，这样修改一下就可以了
Lamp：

1. public enum Lamp {
   
2.         N_E(new Road("东》》西路")),N_W(new Road("东》》北路")),E_N(new Road("西》》东路")),E_S(new Road("西》》南路")),
   
3.         N_S(new Road("东》》南路")),E_W(new Road("西》》北路")),
   
4.         S_W(new Road("南》》北路")),S_N(new Road("南》》东路")),W_S(new Road("北》》南路")),W_E(new Road("北》》西路")),
   
5.         W_N(new Road("北》》东路")),S_E(new Road("南》》西路"));

复制代码

LampContral：

其实在生活中红绿灯是一种交通规则，大家都知道的，如果按照面向对象的思想，灯应该不具有让车走的功能吧。只是人在车上根据当前灯做出判断。呵呵 ，你的方法也行吧。你是一个善于思考的 人啊 。。。

闾丘日月 发表于 2012-6-4 16:35
lz能具体说说和张老师的思想不同在哪里么？

我这里给灯的功能简化了，用一个控制器，分组控制灯的暗灭，
灯亮了 就呼叫车辆通行，不用返回灯的状态、也不用激活下一盏灯、也不用Road（车辆）来不停的监视灯的状态（楼下说这样不符合面向对象编程，感觉有一定道理，不过这样应该有简化程序，如果做嵌入，这个应该会好一点吧）

刘蕴学 发表于 2012-6-4 19:42
额，你这个跟张老师的区别，应该是没有区别，并且你这个如果按照面向对象的观点来看，不太合理，假如你自己 ...

我这里给灯的功能简化了，用一个控制器，分组控制灯的暗灭，
灯亮了 就呼叫车辆通行，不用返回灯的状态、也不用激活下一盏灯、也不用Road（车辆）来不停的监视灯的状态。我只是想着老师那样太复杂了，（当然他是为了教学）开发中不会严格按照面向对象吧？

郭宁 发表于 2012-6-4 21:33
我这里给灯的功能简化了，用一个控制器，分组控制灯的暗灭，
灯亮了 就呼叫车辆通行，不用返回灯的状态 ...

开发中只会更复杂，你这样的硬编码不能自动适应环境

刘蕴学 发表于 2012-6-4 21:56
开发中只会更复杂，你这样的硬编码不能自动适应环境

受教了。关键没接触过什么项目，期待能顺利进入11期黑马，让我离自己的梦再近一点！

郭宁 发表于 2012-6-4 21:59
受教了。关键没接触过什么项目，期待能顺利进入11期黑马，让我离自己的梦再近一点！ ...

给你举个例子吧，其实你这个已经很有起色了，比如三叉路口的话你的灯得怎么办？如果按照你这个来说，三岔路口就会有4种，但实际上3叉路口只有一种。如果是高架桥带十字路口之类的复杂路口，不只12盏灯，你怎么办？每次都修改代码吗？修改的话出现的bug调试以及代码修改的时间都会增加成本？如何自动适应所有路口？另外在左行的国家你这个右行的也不好用了吧？

程序应该仅编写规则，业务逻辑方面应该被剥离，由用户自己扩展

给你点提示，对于这个程序来讲，程序的规则仅仅只是灯组的轮换，灯组是可以自定义的，至于灯的状态也应该是可以自定义，这样你的这个框架将不会在局限于3个灯的程序，而灯组这一块应该是用户自己根据路口的实际情况来定义的，这样可以适应所有的复杂路口，你的框架仅仅只应该根据用户定义的这些灯组进行轮换，至于轮换规则则是用户来定义的，在一个关于灯的问题，灯一定是红黄绿么？如果是红灯完了黄灯，黄灯过后绿灯，绿灯之后黄灯，黄灯之后在红灯这样的轮换呢？至少来说灯的转换也不见得是固定的吧？

最后，不要管东南西北，东南西北是人设定的，但是灯知道东南西北吗？如果是定义东南西北的话会使设计思想变得复杂化？对于这个程序而言，只需要知道灯的代号就行，至于是东南西北，1234都可以，思想不要被固化。

至于更高级点的设计，灯应该存在常绿的以及长红的，对吧，交通等管理系统，那交通部门根据实际情况进行引导的话，某些街道的灯是会被设置长红的吧？在引导完成之后在恢复回来，这样来说你就得有这两个屏蔽列表，你的灯组进行轮换的时候应该检查这两个屏蔽列表以达到不修改这些灯的目的

刘蕴学 发表于 2012-6-4 22:29
给你举个例子吧，其实你这个已经很有起色了，比如三叉路口的话你的灯得怎么办？如果按照你这个来说，三岔 ...

么么哒~ 差距在哪里，差距就在这里。还说什么呢？思考去了~~~

郭宁 发表于 2012-6-4 23:11
么么哒~ 差距在哪里，差距就在这里。还说什么呢？思考去了~~~

呵呵，没什么差距不差距的，老张说的好，没有程序员搞不定的东西，只不过有的人稍微快那么一点

如果你基础已经差不多了，多做做这些小项目，提高的会比较快，光埋头学是没什么成果的

不错···高手往往就这么突然出现了

不错···高手往往就这么突然出现了