日夜复习,只为进黑马.各种努力!以下是个人写的交通灯,请大牛帮忙分析分析,哪里好与不好!!!!多谢!!!!!!

1. package TrafficLampDemo;
   
2. 
   
3. public enum Lamp {
   
4.         Lamp1, Lamp2, Lamp3, Lamp4;
   
5.        
   
6.         /* 一共有四种灯
   
7.          * S2N,N2S        Lamp1
   
8.          * S2W,N2E        Lamp2
   
9.          * E2W,W2E        Lamp3
   
10.          * E2S,W2N        Lamp4
    
11.          */
    
12. 
    
13.         //四种灯的顺序
    
14.         public Lamp nextLamp() {
    
15.                 switch (this) {
    
16.                 case Lamp1:
    
17.                         return Lamp2;
    
18.                 case Lamp2:
    
19.                         return Lamp3;
    
20.                 case Lamp3:
    
21.                         return Lamp4;
    
22.                 case Lamp4:
    
23.                         return Lamp1;
    
24.                 }
    
25.                 return null;
    
26.         }
    
27. 
    
28.        
    
29.         //打印中文
    
30.         public String toString() {
    
31.                 String name = null;
    
32.                 switch (this) {
    
33.                 case Lamp1:
    
34.                         name = "从南到北,从北到南";
    
35.                         break;
    
36.                 case Lamp2:
    
37.                         name = "从南到西,从北到东";
    
38.                         break;
    
39.                 case Lamp3:
    
40.                         name = "从东到西,从西到东";
    
41.                         break;
    
42.                 case Lamp4:
    
43.                         name = "从东到南,从西到北";
    
44.                         break;
    
45.                 }
    
46.                 return name;
    
47.         }
    
48. }
    

复制代码

1. package TrafficLampDemo;
   
2. 
   
3. import java.util.concurrent.Executors;
   
4. import java.util.concurrent.TimeUnit;
   
5. 
   
6. public class LampControl {
   
7.        
   
8.         //设置一个默认灯
   
9.         private Lamp currentLamp = Lamp.Lamp1;
   
10.        
    
11.         //这个数组其实可以不写的,下面数字调用的就是这个数组的脚标
    
12.         String[] roads = { "S2N", "S2W", "E2W", "E2S", "N2S", "N2E", "W2E", "W2N"};
    
13. 
    
14.         //构造函数,新建对象时控制灯的转换
    
15.         LampControl() {
    
16.                 System.out.println(currentLamp+"绿灯了");
    
17.                 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
    
18.                         public void run() {
    
19.                                 System.out.println(currentLamp+"红灯了");
    
20.                                 currentLamp = currentLamp.nextLamp();//10秒跳转灯
    
21.                                 System.out.println(currentLamp+"绿灯了");
    
22.                         }
    
23.                 }, 10, 10, TimeUnit.SECONDS);
    
24.         }
    
25. 
    
26.         public void start() {
    
27.                
    
28.                 //每秒检查一次当前什么灯在亮
    
29.                 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
    
30.                         public void run() {
    
31.                                 switch (currentLamp) {
    
32.                                 case Lamp1:
    
33.                                         cross(0, 4);
    
34.                                         break;
    
35.                                 case Lamp2:
    
36.                                         cross(1, 5);
    
37.                                         break;
    
38.                                 case Lamp3:
    
39.                                         cross(2, 6);
    
40.                                         break;
    
41.                                 case Lamp4:
    
42.                                         cross(3, 7);
    
43.                                         break;
    
44.                                 }
    
45.                         }
    
46.                 }, 1, 1, TimeUnit.SECONDS);
    
47.         }
    
48. 
    
49.         //绿灯的车1秒通过一个
    
50.         public void cross(int x, int y) {
    
51.                
    
52.                 //两个相对应的方向
    
53.                 Road road1 = Road.valueOf(roads[x]);
    
54.                 Road road2 = Road.valueOf(roads[y]);
    
55.                
    
56.                 //判断是否有车,有车就过
    
57.                 Integer num1 = road1.crossCar();
    
58.                 Integer num2 = road2.crossCar();       
    
59.                 if (num1 != null | num2 != null) {
    
60.                         if (num1 != null) {
    
61.                                 System.out.println(road1 + "的第" + num1 + "辆车开过去了");
    
62.                         }
    
63.                         if (num2 != null) {
    
64.                                 System.out.println(road2 + "的第" + num2 + "辆车开过去了");
    
65.                         }
    
66.                         try {
    
67.                                 Thread.sleep(900);
    
68.                         }
    
69.                         catch (InterruptedException e) {
    
70.                                 e.printStackTrace();
    
71.                         }
    
72.                 }
    
73.         }
    
74. 
    
75. }
    

复制代码

1. package TrafficLampDemo;
   
2. 
   
3. import java.util.LinkedList;
   
4. import java.util.Random;
   
5. import java.util.concurrent.Executors;
   
6. import java.util.concurrent.TimeUnit;
   
7. 
   
8. public enum Road {
   
9.         //S是南 N是北 W是西 E是东
   
10.         S2N,S2W,E2W,E2S,
    
11.         N2S,N2E,W2E,W2N,
    
12.         S2E,E2N,N2W,W2S;
    
13.        
    
14.         int lastCar = 1;
    
15.         //这里紧紧是增删操作,我觉得用LinkedList比较好
    
16.         LinkedList<Integer> list = new LinkedList<Integer>();
    
17.        
    
18.         //每一个路都可以独立随机产生车辆
    
19.         public synchronized void produceCar(){
    
20.                 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable(){
    
21.                         public void run(){
    
22.                                 list.addLast(lastCar++);
    
23.                                
    
24.                         }
    
25.                 }, 1, new Random().nextInt(10)+1, TimeUnit.SECONDS);
    
26.         }
    
27.        
    
28.         //让绿灯去调用,让车辆过
    
29.         public synchronized Integer crossCar(){
    
30.                 if(list.size()!=0){
    
31.                         return list.removeFirst();
    
32.                 }
    
33.                 return null;
    
34.         }
    
35.        
    
36.        
    
37.         //打印中文
    
38.         public String toString(){
    
39.                 switch(this){
    
40.                 case S2N:
    
41.                         return "从南到北";
    
42.                 case S2W:
    
43.                         return "从南到西";
    
44.                 case E2W:
    
45.                         return "从东到西";
    
46.                 case E2S:
    
47.                         return "从东到南";
    
48.                 case N2S:
    
49.                         return "从北到南";
    
50.                 case N2E:
    
51.                         return "从北到东";
    
52.                 case W2E:
    
53.                         return "从西到东";
    
54.                 case W2N:
    
55.                         return "从西到北";
    
56.                 case S2E:
    
57.                         return "从南到东";
    
58.                 case E2N:
    
59.                         return "从东到北";
    
60.                 case N2W:
    
61.                         return "从北到西";
    
62.                 case W2S:
    
63.                         return "从西到南";
    
64.                 }               
    
65.                 return null;
    
66.         }
    
67. }
    

复制代码

1. package TrafficLampDemo;
   
2. 
   
3. import java.util.concurrent.Executors;
   
4. import java.util.concurrent.TimeUnit;
   
5. 
   
6. public class MainClass {
   
7.         static int num ;
   
8.         public static void main(String[] args) {
   
9.                 final String[] roads = { "S2N", "S2W", "E2W", "E2S", "N2S", "N2E",
   
10.                                 "W2E", "W2N", "S2E", "E2N", "N2W", "W2S" };
    
11.                
    
12.                 // 每条路随机产生车辆
    
13.                 for (int i = 0; i < roads.length; i++) {
    
14.                         Road.valueOf(roads[i]).produceCar();
    
15.                 }
    
16. 
    
17.                 //此处是没有灯的右转模拟,如果想要看模拟就把注释打开
    
18.                 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
    
19.                         public void run() {
    
20.                                 for (int i = 8; i < roads.length; i++) {
    
21.                                         Road road = Road.valueOf(roads[i]);
    
22.                                         Integer num = road.crossCar();
    
23.                                         if (num != null) {
    
24.                                                 //System.out.println(road + "的第" + num + "辆车开过去了");
    
25.                                                 try {
    
26.                                                         Thread.sleep(1000);
    
27.                                                 }
    
28.                                                 catch (InterruptedException e) {
    
29.                                                         e.printStackTrace();
    
30.                                                 }
    
31.                                         }                                       
    
32.                                 }
    
33.                         }
    
34.                 }, 1, 1, TimeUnit.SECONDS);
    
35. 
    
36.                 //开启交通灯控制
    
37.                 new LampControl().start();
    
38. 
    
39.         }
    
40. }
    

复制代码

顶起来，

表示还没学到这部分哈 。。。。。。

来个大牛帮小弟分析一下吧!!!多谢指点啊!!!!!