黑马程序员 交通灯系统

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

1，张老师在一开始为了提高同学们的面向对象的设计思维能力，便引出了两个例子：

例一：两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材做成椅子

张老师的是这样设计的：

首先有这样几个类

Stone//石头

StoneKnife//石刀，这个类里面有一个publicMaterial cut(Tree tree)方法

Material//材料

Tree//树

Chair//椅子

然后张老师想到石头磨出刀后石头自己就应该没了，材料做成椅子后也应该没了，张老师觉得这样的思想如果要设计到对象所对应的类里面就比较难以实现，所以就又设计了两个工厂类

KnifeFactory//这个类里面有个createKnife(Stonestone1,Stone stone2)方法

ChairFactory//这个类里面有个makeChair(Materialmaterial)方法

个人觉得张老师的设计这两个工厂类是没有必要的，类多了就过于复杂了，况且他这样设计似乎也没有达到让对象自己把自己变没了的目的，下面我给出我的设计，个人觉得比张老师的要好点，也许我的还没有他设计的好，仅供交流，呵呵……

1.    
2.   
3. public class CharMake {  
4.     public static void main(String[] args) {  
5.         StoneKnife stoneKnife = new Stone().produceStoneKnife(new Stone());// 磨刀  
6.         Wood wood = stoneKnife.cutTree(new Tree(20));// 砍树  
7.         wood.makeChar();// 做成椅子  
8.     }  
9. }  
10.   
11. /* 定义一个Stone类来封装石头 */  
12. class Stone {  
13.     private int life = 1;// 表示石头的生命，磨出一把石刀后就不存在了，即生命变为0  
14.   
15.     public StoneKnife produceStoneKnife(Stone stone) {  
16.         if (1 == this.life & 1 == stone.life) {  
17.             this.life = 0;  
18.             stone.life = 0;// 石刀麻成后，两块石头就不存在了，所以生命为0  
19.             System.out.println("两块石头磨成一把石刀");  
20.             return new StoneKnife();// 返回生产出来的石刀  
21.         }  
22.         System.out.println("制刀失败");  
23.         return null;  
24.     }  
25. }  
26.   
27. /* 定义一个StoneKnife类来封装石刀 */  
28. class StoneKnife {  
29.     private int life = 100;// 表示石刀的生命，  
30.   
31.     public Wood cutTree(Tree tree) {  
32.         if (tree.getLife() > 0 & life > tree.getLife()) {  
33.             int treeLife = tree.getLife();  
34.             life -= treeLife;// 每砍完一棵树，石刀就根据树的大小而减少相应的生命值  
35.             tree.setLife(0);// 树被砍了后生命变为0  
36.             System.out.println("石刀可以砍树，砍成木材");  
37.             return new Wood(treeLife);// 树的生命转化为木材的生命  
38.         }  
39.         System.out.println("砍树失败");  
40.         return null;  
41.     }  
42. }  
43.   
44. /* 定义一个Tree类来封装树 */  
45. class Tree {  
46.     private int life;// 树的生命  
47.   
48.     public Tree(int life) {  
49.         this.life = life;  
50.     }  
51.   
52.     public int getLife() {  
53.         return life;  
54.     }  
55.   
56.     public void setLife(int life) {  
57.         this.life = life;  
58.     }  
59. }  
60.   
61. /* 定义一个Wood类来封装木材 */  
62. class Wood {  
63.     private int life;// 木材的生命  
64.   
65.     public Wood(int life) {  
66.         this.life = life;  
67.     }  
68.   
69.     public Chair makeChar() {  
70.         if (life >= Chair.wood) {  
71.             life -= Chair.wood;// 木材做出来一把椅子后，就减少相应的生命值  
72.             System.out.println("木材可以做成椅子");  
73.             return new Chair();  
74.         }  
75.         System.out.println("制作椅子失败");  
76.         return null;  
77.     }  
78.   
79.     public int getLife() {  
80.         return life;  
81.     }  
82.   
83.     public void setLife(int life) {  
84.         this.life = life;  
85.     }  
86. }  
87.   
88. /* 定义一个Chair类来封装椅子 */  
89. class Chair {  
90.     public static int wood = 2;// 制作一把椅子需要消耗的木材资源  
91. }  

例二：球从一根绳子的一端移动到了另一端

张老师是这样设计 的

1.    
2. class Rope{  
3.     private Point start;  
4.     private Point end;  
5.     public Rope(Point start, Point end){  
6.         this.start = start;  
7.         this.end = end;  
8.     }  
9.     public Point nextPoint(Point currentPoint){  
10.         /*通过两点一线的数学公式可以计算出当前点的下一个点，这个细节不属于设计阶段要考虑的问题， 
11.          * 如果当前点是终止点，则返回null,如果当前点不是线上的点则抛出异常 
12.          * */  
13.     }  
14. }  
15. class Ball{  
16.     private Rope rope;  
17.     private Point currentPoint;  
18.     public Ball(Rope rope,Point startPoint){  
19.         this.rope = rope;  
20.         this.currentPoint = startPoint;  
21.     }  
22.     public void move(){  
23.         currentPoint = rope.nextPoint(currentPoint);  
24.         System.out.println("小球移动到了"+currentPoint);  
25.     }  
26. }  

我是这样设计的

1.    
2. public class ballMove {  
3.     public static void main(String[] args) {  
4.         new Ball().moveOnRope(new Rope(30));  
5.     }  
6. }  
7.   
8. /* 定义一个Ball类来代表球 */  
9. class Ball {  
10.     /* moveOnRope方法模拟球在绳子上移动的过程 */  
11.     public void moveOnRope(Rope rope) {  
12.         System.out.println("出发");  
13.         for (int i = 0; i <= rope.getLength(); i++) {  
14.             System.out.println("已经走了" + i + "米");  
15.         }  
16.         System.out.println("到达另一端");  
17.     }  
18. }  
19.   
20. /* 定义一个Rope类来代表绳子 */  
21. class Rope {  
22.     private int length;  
23.   
24.     public Rope(int length) {  
25.         this.length = length;  
26.     }  
27.   
28.     public int getLength() {  
29.         return length;  
30.     }  
31. }  

我觉得我和张老师的不同就在于他把绳子设计在了一个二维空间里，而我则是把绳子设计在了一个一维空间里

下面是我自己模拟的这个交通灯系统

1.    
2. package com.isoftstone.interview.traffic;  
3.   
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import java.util.Random;  
7.   
8. public class MainClass {  
9.     public static void main(String[] args) {  
10.         new Controller();  
11.     }  
12. }  
13.   
14. class Controller {  
15.     /* 
16.      * 一个十字路口就是两条路相交，所以这里创建两条路 一条东西干道，一条南北干道 初始状态为东西干道的绿灯亮，南北干道的红灯亮 
17.      */  
18.     private Road roadEW = new Road(true, "东西干道");  
19.     private Road roadSN = new Road(false, "南北干道");  
20.   
21.     public Controller() {  
22.         System.out.println("东西干道 绿灯亮，南北干道红灯亮");// 打印初始状态  
23.         new Thread(new Runnable() {  
24.             @Override  
25.             public void run() {  
26.                 while (true) {  
27.                     try {  
28.                         Thread.sleep(30000);  
29.                     } catch (InterruptedException e) {  
30.                         e.printStackTrace();  
31.                     }  
32.                     roadEW.changeLight();  
33.                     roadSN.changeLight();  
34.                 }  
35.             }  
36.   
37.         }).start();// 每隔30秒换次信号灯  
38.     }  
39. }  
40.   
41. class Road {  
42.     /* 每条道上的车的去向只有3个，即向左转，直行，向右转 */  
43.     private static final String[] goTo = { "left", "front", "right" };  
44.     /* 
45.      * 每条道上都有一个信号等，本来这里可以是静态的，但是为了体现面向对象的设计思想， 我就没有把它定义为静态的 
46.      */  
47.     private boolean light;  
48.     /* 保存路的名字，这主要是为了方便测试，在打印时可以打印出是哪条路在通行 */  
49.     private String name;  
50.   
51.     /** 
52.      *  
53.      * @param light 
54.      *            道路上路灯的初始状态 
55.      * @param name 
56.      *            道路的名字 
57.      */  
58.     public Road(boolean light, String name) {  
59.         this.light = light;  
60.         this.name = name;  
61.         /* 当道路一创建，道路上就开始行驶车辆了 */  
62.         this.removeThread(left, "左边");  
63.         this.removeThread(right, "右边");  
64.         this.addThread(left);  
65.         this.addThread(right);  
66.     }  
67.   
68.     public void changeLight() {  
69.         light = true == light ? false : true;// 路灯转换  
70.         if (light) {  
71.             System.out.println(this.name + "绿灯亮，");  
72.         } else {  
73.             System.out.println(this.name + "红灯亮，");  
74.         }  
75.     }  
76.   
77.     public void removeThread(final List<car> list, final String listname) {  
78.         new Thread(new Runnable() {  
79.   
80.             @Override  
81.             public void run() {  
82.                 while (true) {  
83.                     try {  
84.                         Thread.sleep(1000);  
85.                     } catch (InterruptedException e) {  
86.                         e.printStackTrace();  
87.                     }  
88.                     if (0 != list.size()) {// 如果道上的车辆数不为0  
89.                         if (Road.this.light  
90.                                 | list.get(0).getGoTo().equals("right")) {  
91.                             /* 道路上亮的是绿灯或者最前面的那辆车是向右转就旅行 */  
92.                             System.out.println(Road.this.name + listname  
93.                                     + "使过一辆向" + list.get(0).getGoTo()  
94.                                     + "方向行驶的车");  
95.                             list.remove(0);  
96.                         }  
97.                     }  
98.                 }  
99.             }  
100.         }).start();  
101.     }  
102.   
103.     public void addThread(final List<car> list) {  
104.         new Thread(new Runnable() {  
105.   
106.             @Override  
107.             public void run() {  
108.                 while (true) {  
109.                     try {  
110.                         Thread.sleep(1000);  
111.                     } catch (InterruptedException e) {  
112.                         e.printStackTrace();  
113.                     }  
114.                     /* 增加车辆 */  
115.                     list.add(new Car(goTo[new Random().nextInt(3)]));  
116.                 }  
117.             }  
118.         }).start();  
119.     }  
120.   
121.     /* 每条道路都是双向道，所以我们这里就用两个集合来存储这两个道上的车辆 */  
122.     private List<car> left = new ArrayList<car>();  
123.     private List<car> right = new ArrayList<car>();  
124. }  
125.   
126. class Car {  
127.     private String goTo;// 储存车辆的去向，左转，直行或者右转  
128.   
129.     public Car(String goTo) {  
130.         this.goTo = goTo;  
131.     }  
132.   
133.     /* 获取车辆的去向 */  
134.     public String getGoTo() {  
135.         return goTo;  
136.     }  
137. }  
138. </car></car></car></car></car></car>