黑马程序员——交通灯管理系统
2014-05-08 22:56
197 查看
黑马程序员——交通灯管理系统
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流! -------------------------------
一、需求:
模拟实现十字路口的交通灯管理系统逻辑,具体需求如下:
异步随机生成按照各个路线行驶的车辆。
例如:
由南向而来去往北向的车辆 ---- 直行车辆
由西向而来去往南向的车辆 ---- 右转车辆
由东向而来去往南向的车辆 ---- 左转车辆
。。。
信号灯忽略黄灯,只考虑红灯和绿灯。
应考虑左转车辆控制信号灯,右转车辆不受信号灯控制。
二、面向对象的设计分析
1.类的分析
面向对象设计把握一个重要的经验:谁拥有数据,谁就对外提供操作这些数据的方法。例如:
火车司机刹车:刹车这个方法是车提供的,刹车动作是刹车系统内部完成的,司机没那么力气是火车停下了,司机发出刹车指令。
人在黑白画圆:画园动作用到 圆心、园半径R ,人画圆圈需要用到这些数据,这些数据是圆提供的,方法再圆上,不应该定义在人身上。
人关门:关门方法是门提供的,门有转轴,轴心转动,转动关门的方法定义在门身上,人只是提供一外力推一下,调用关门的方法。
1、“两块石头磨成了一把石刀,石刀可以砍树,砍成木头,木头做成椅子”
分析:石头变成石刀,不是自己变成石到,通过其他磨成刀。如石刀加工成,磨刀方法定义在石刀加工场,接收参数(两块石头)
石刀来砍树,有砍树方法 ,木头变成椅子,不是自己变成的,是被加工成使用,变成椅子的方法定义在加工场。
2、“球从一根绳子的一段移动到另一端”分析其有多少个对象。
分析:绳子,有长度,有两个结束点的坐标。提供一个点到下一个点的方法,球滚动,提供滚动的方法,怎么滚
2.类的功能分析:
a. 要有红绿灯的控制系统,指挥灯的颜色变化。
b.车在这条路上行驶,对应的等是绿色的才通行。其那面还有车,这条路相当于一个集合中有很多车。
c、路线集合中存储的汽车,车会拐弯,穿过、过程增加和减少车辆,减少的方法是路提供,对象是路线 。
d.设计类就需要 1.红绿灯、2.红绿灯控制系统,3.路线(车相当于是路线里面的一个元素) 三个类。
分析 路线:1.总共会有12条路线(南到北有(直走、左拐、右拐),四个方向共12条路线) 即系统中总共要产生12个路线实例对象。
2.每条路线上随机增加新的车辆,把车子增加到一个集合中保存,每条路线每隔一秒都会检查控制本路线的灯是否为绿,
是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
灯: 1.既然是12条路线,所以,系统中总共要产生12个交通灯。一个灯由绿变红时,应该将下一个方向的灯变绿。右拐弯的路线本来不受灯的控制
2.右拐弯方向的其他8条路线的灯,它们是两两成对的,可以归为4组, 南到北灯是绿的、相对的北到南也是绿的。
所以,只要从这4组中各取出一个灯,对这4个灯依次轮询变亮,与这4个灯方向对应的灯则随之一同变化,因此Lamp类中要有一个变量来记住自己相反方向的灯,、
在一个Lamp对象的变亮和变黑方法中,将对应方向的灯也变亮和变黑。每个灯变黑时,都伴随者下一个灯的变亮,Lamp类中还用一个变量来记住自己的下一个灯。
3.设计灯的控制类,定时让绿灯变红
三编写类:
1.编写路线这个Road 类
分析:1.每条路线都有一个成员变量name属性代表方向路线 List集合存放该方向上的车辆
2.在Road对象的构造方法中启动一个线程每隔一个随机的时间,List集合中增加车辆
3、在Road对象的构造方法中启动一个定时器,每隔一秒检查该方向上的灯是否为绿,
是则打印车辆集合和将集合中的第一辆车移除掉
package com.itheima.traffic;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Road {
/**
* @Author hutian
*/
//每创建一条路线定义个名字
private String name=null;
// 路线的集合存放路上跑的车
private List<String> list=new ArrayList<String>();
public Road(String name){
this.name=name;
//启动一个线程,每隔一个随机的时间向list 集合中添加一辆车
// 提供一个线程池,产出都是一组线程,池来控制线程,那个空闲调用那个。
ExecutorService pool = Executors.newSingleThreadExecutor() ;
pool.execute(new Runnable(){
@Override
public void run() {
for(int i=1;i<1000;i++){
try {
//1秒到10秒钟内随机会有车经过
Thread.sleep((new Random().nextInt(10)+1)*1000);
} catch (Exception e) {
// TODO: handle exception
}
//内部类访问外部类的成员变量:
list.add(Road.this.name+"_"+i) ;
}
}
});
// 启动一个定时器,每隔一秒检查该方向上的灯是否为绿色,如果是绿灯就放行
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1) ;
timer.scheduleAtFixedRate(new Runnable(){
@Override
public void run() {
// //该路上的车辆是否大于0,路上有车跑
if(list.size()>0){
//该路上的灯是否为绿;如果为绿则车辆通过路口
//boolean lighted=true;
// 得到路线,确定灯状态
boolean lighted =Lamp.valueOf(Road.this.name).isLighted();
if(lighted){
//返回某个车 状态
System.out.println(list.remove(0)+"is running!");
}
}
}
}, 1, 1, TimeUnit.SECONDS);
}
}
2.编写灯Lamp这个类
分析:1.使用枚举形式定义,根据灯的名称就可以获得对应的灯的实例对象。
2.南北向车辆与东西向车辆交替方向,同向等待车辆应该先放行直行车辆
3.每个Lamp对象都有亮、黑的状态,S2N、S2W、E2W、E2N这四个方向上的Lamp对象依次轮询变亮。
定义一个相反方向的灯,下一个变亮的灯,用构造方法进行赋值。
4.定义变亮和变黑的方法light和blackOut,对于S2N、S2W、E2W、E2N这四个方向上的Lamp对象,
这两个方法内部要让相反方向的灯随之变亮和变黑,(如南往北,北往南相向的灯一致)blackOut方法还要让下一个灯变亮。
5.S2N、S2W、E2W、E2N这四个方向上的Lamp对象的nextLampName和oppositeLampName属性必须设置为null,
以便防止light和blackOut进入死循环。
package com.itheima.traffic;
public enum Lamp {
/**
* @param args
* 。
*/
//每条路线上对应的灯:true为绿,false为红
S2N(false,"N2S","S2W"),S2W(false,"N2E","E2W"),E2W(false,"W2E","E2S"),E2S(false,"W2N","S2N"),
//下面四条路线对应上面四条路线,它们的“相反方向灯”和“下一个灯”应忽略不计!
N2S(false,null,null),N2E(false,null,null),W2E(false,null,null),W2N(false,null,null),
//应为向右方向的车不受控制,所以,可以假想它们总是绿灯
S2E(true,null,null),E2N(true,null,null),N2W(true,null,null),W2S(true,null,null);
private Lamp(boolean ligthed,String opposite , String next){
this.ligthed=ligthed;
this.opposite=opposite;
this.next=next;
}
// 设计灯,每条路线上对应的灯:true为绿,false为红灯
private boolean ligthed;
// 定义一个对应灯的变量 如S2N -> N2S
private String opposite;
// 表示此灯变绿后下一个变绿的灯
private String next ;
public static void main(String[] args) {
// TODO Auto-generated method stub
}
//判断灯状态,返回灯
public boolean isLighted(){
return ligthed;
}
//灯变亮的方法
public void light(){
this.ligthed=true;
if(opposite!=null){
((Lamp) Lamp.valueOf(opposite)).light();//返回枚举对应的名字对象
//opposite.light(); //对应灯
}
System.out.println(name() + " lamp is green,下面总共应该有6个方向能看到汽车穿过!");
}
// 灯熄灭变黑
public Lamp blackOut(){
this.ligthed=false;
if(opposite!=null){
Lamp.valueOf(opposite).blackOut();// 灯变黑
}
//我变黑了,要让下个灯变绿
Lamp nextLamp=null;
if(next!=null){
nextLamp = Lamp.valueOf(next);
System.out.println( name()+"变红!" + next +"下个变绿!");
nextLamp.light();
}
return nextLamp;
}
}
3.灯控制系统LampController 类的编写
分析:
1、整个系统中只能有一套交通灯控制系统,所以,LampController类最好是设计成单例。
2、LampController构造方法中要设定第一个为绿的灯。
3、LampController对象的start方法中将当前灯变绿,然后启动一个定时器,每隔10秒将当前灯变红和将下一个灯变绿。
package com.itheima.traffic;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import javax.swing.Timer;
public class LampController {
/**
* @param args
*/
// 当前为绿的灯
private Lamp currentLamp;
public LampController(){
currentLamp=Lamp.S2N;// 南到北
currentLamp.light();//亮
//启动一个定时器:每隔10秒将当前灯变红和下一个灯变绿
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run(){
System.out.println("交通运行开始啦!");
currentLamp = currentLamp.blackOut();
}
},
10,//每隔10秒变换
10,
TimeUnit.SECONDS);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
编写TestTraffic测试
package com.itheima.traffic;
public class TestTraffic {
/**
* @param args
*/
public static void main(String[] args) {
String[] directions = {"S2N","N2S","S2W","N2E","E2W","W2E",
"E2S","W2N","S2E","N2W","E2N","W2S"};
// 1、用for循环创建出代表12条路线的对象。
for(int i = 0 ; i < directions.length ; i ++) {
new Road(directions[i]) ;
}
//获取LampController对象并调用其start方法运行交通系统
new LampController() ;
}
}
打印结果:
N2S lamp is green,下面总共应该有6个方向能看到汽车穿过!
S2N lamp is green,下面总共应该有6个方向能看到汽车穿过!
E2N_1is running!
S2E_1is running!
W2S_1is running!
E2N_2is running!
S2N_1is running!
N2W_1is running!
W2S_2is running!
交通运行开始啦!
S2N变红!S2W下个变绿!
N2E lamp is green,下面总共应该有6个方向能看到汽车穿过!
S2W lamp is green,下面总共应该有6个方向能看到汽车穿过!
S2W_1is running!
N2E_1is running!
E2N_3is running!
N2E_2is running!
N2E_3is running!
S2E_2is running!
E2N_4is running!
S2E_3is running!
S2W_2is running!
N2W_2is running!
S2E_4is running!
S2W_3is running!
W2S_3is running!E2N_5is running!交通运行开始啦!
S2W变红!E2W下个变绿!
W2E lamp is green,下面总共应该有6个方向能看到汽车穿过!
E2W lamp is green,下面总共应该有6个方向能看到汽车穿过!
E2W_1is running!
W2E_1is running!
E2N_6is running!
E2W_2is running!
E2N_7is running!
W2E_2is running!
W2S_4is running!
E2W_3is running!
W2E_3is running!
N2W_3is running!
S2E_5is running!
W2S_5is running!
E2W_4is running!
W2E_4is running!
N2W_4is running!
交通运行开始啦!
总结:主要学会分析思路,没分析清楚是敲不出代码。
1.交通灯管理系统,先分清多少路线,东南西北四个方向,每个方向车都右向左、向右、直行的路线对象是路线,共12条。
2.不是定义车这个对象,不管是摩托车、还是汽车、车始终相当于路线合中的一个元素,路这个对象来控制车,关注的是路线方向。
3.线程管理中,产出都是一组线程,池来控制线程,那个空闲调用那个。
4.右拐弯的方向灯可不计影响看做全部绿灯,因为同一线路上前行灯是绿色通行的话,右方向的即可通行。
面向对象思想:路提供各个方向行驶的方法,谁拥有数据谁提供方法。
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流! -------------------------------
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流! -------------------------------
一、需求:
模拟实现十字路口的交通灯管理系统逻辑,具体需求如下:
异步随机生成按照各个路线行驶的车辆。
例如:
由南向而来去往北向的车辆 ---- 直行车辆
由西向而来去往南向的车辆 ---- 右转车辆
由东向而来去往南向的车辆 ---- 左转车辆
。。。
信号灯忽略黄灯,只考虑红灯和绿灯。
应考虑左转车辆控制信号灯,右转车辆不受信号灯控制。
二、面向对象的设计分析
1.类的分析
面向对象设计把握一个重要的经验:谁拥有数据,谁就对外提供操作这些数据的方法。例如:
火车司机刹车:刹车这个方法是车提供的,刹车动作是刹车系统内部完成的,司机没那么力气是火车停下了,司机发出刹车指令。
人在黑白画圆:画园动作用到 圆心、园半径R ,人画圆圈需要用到这些数据,这些数据是圆提供的,方法再圆上,不应该定义在人身上。
人关门:关门方法是门提供的,门有转轴,轴心转动,转动关门的方法定义在门身上,人只是提供一外力推一下,调用关门的方法。
1、“两块石头磨成了一把石刀,石刀可以砍树,砍成木头,木头做成椅子”
分析:石头变成石刀,不是自己变成石到,通过其他磨成刀。如石刀加工成,磨刀方法定义在石刀加工场,接收参数(两块石头)
石刀来砍树,有砍树方法 ,木头变成椅子,不是自己变成的,是被加工成使用,变成椅子的方法定义在加工场。
2、“球从一根绳子的一段移动到另一端”分析其有多少个对象。
分析:绳子,有长度,有两个结束点的坐标。提供一个点到下一个点的方法,球滚动,提供滚动的方法,怎么滚
2.类的功能分析:
a. 要有红绿灯的控制系统,指挥灯的颜色变化。
b.车在这条路上行驶,对应的等是绿色的才通行。其那面还有车,这条路相当于一个集合中有很多车。
c、路线集合中存储的汽车,车会拐弯,穿过、过程增加和减少车辆,减少的方法是路提供,对象是路线 。
d.设计类就需要 1.红绿灯、2.红绿灯控制系统,3.路线(车相当于是路线里面的一个元素) 三个类。
分析 路线:1.总共会有12条路线(南到北有(直走、左拐、右拐),四个方向共12条路线) 即系统中总共要产生12个路线实例对象。
2.每条路线上随机增加新的车辆,把车子增加到一个集合中保存,每条路线每隔一秒都会检查控制本路线的灯是否为绿,
是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
灯: 1.既然是12条路线,所以,系统中总共要产生12个交通灯。一个灯由绿变红时,应该将下一个方向的灯变绿。右拐弯的路线本来不受灯的控制
2.右拐弯方向的其他8条路线的灯,它们是两两成对的,可以归为4组, 南到北灯是绿的、相对的北到南也是绿的。
所以,只要从这4组中各取出一个灯,对这4个灯依次轮询变亮,与这4个灯方向对应的灯则随之一同变化,因此Lamp类中要有一个变量来记住自己相反方向的灯,、
在一个Lamp对象的变亮和变黑方法中,将对应方向的灯也变亮和变黑。每个灯变黑时,都伴随者下一个灯的变亮,Lamp类中还用一个变量来记住自己的下一个灯。
3.设计灯的控制类,定时让绿灯变红
三编写类:
1.编写路线这个Road 类
分析:1.每条路线都有一个成员变量name属性代表方向路线 List集合存放该方向上的车辆
2.在Road对象的构造方法中启动一个线程每隔一个随机的时间,List集合中增加车辆
3、在Road对象的构造方法中启动一个定时器,每隔一秒检查该方向上的灯是否为绿,
是则打印车辆集合和将集合中的第一辆车移除掉
package com.itheima.traffic;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Road {
/**
* @Author hutian
*/
//每创建一条路线定义个名字
private String name=null;
// 路线的集合存放路上跑的车
private List<String> list=new ArrayList<String>();
public Road(String name){
this.name=name;
//启动一个线程,每隔一个随机的时间向list 集合中添加一辆车
// 提供一个线程池,产出都是一组线程,池来控制线程,那个空闲调用那个。
ExecutorService pool = Executors.newSingleThreadExecutor() ;
pool.execute(new Runnable(){
@Override
public void run() {
for(int i=1;i<1000;i++){
try {
//1秒到10秒钟内随机会有车经过
Thread.sleep((new Random().nextInt(10)+1)*1000);
} catch (Exception e) {
// TODO: handle exception
}
//内部类访问外部类的成员变量:
list.add(Road.this.name+"_"+i) ;
}
}
});
// 启动一个定时器,每隔一秒检查该方向上的灯是否为绿色,如果是绿灯就放行
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1) ;
timer.scheduleAtFixedRate(new Runnable(){
@Override
public void run() {
// //该路上的车辆是否大于0,路上有车跑
if(list.size()>0){
//该路上的灯是否为绿;如果为绿则车辆通过路口
//boolean lighted=true;
// 得到路线,确定灯状态
boolean lighted =Lamp.valueOf(Road.this.name).isLighted();
if(lighted){
//返回某个车 状态
System.out.println(list.remove(0)+"is running!");
}
}
}
}, 1, 1, TimeUnit.SECONDS);
}
}
2.编写灯Lamp这个类
分析:1.使用枚举形式定义,根据灯的名称就可以获得对应的灯的实例对象。
2.南北向车辆与东西向车辆交替方向,同向等待车辆应该先放行直行车辆
3.每个Lamp对象都有亮、黑的状态,S2N、S2W、E2W、E2N这四个方向上的Lamp对象依次轮询变亮。
定义一个相反方向的灯,下一个变亮的灯,用构造方法进行赋值。
4.定义变亮和变黑的方法light和blackOut,对于S2N、S2W、E2W、E2N这四个方向上的Lamp对象,
这两个方法内部要让相反方向的灯随之变亮和变黑,(如南往北,北往南相向的灯一致)blackOut方法还要让下一个灯变亮。
5.S2N、S2W、E2W、E2N这四个方向上的Lamp对象的nextLampName和oppositeLampName属性必须设置为null,
以便防止light和blackOut进入死循环。
package com.itheima.traffic;
public enum Lamp {
/**
* @param args
* 。
*/
//每条路线上对应的灯:true为绿,false为红
S2N(false,"N2S","S2W"),S2W(false,"N2E","E2W"),E2W(false,"W2E","E2S"),E2S(false,"W2N","S2N"),
//下面四条路线对应上面四条路线,它们的“相反方向灯”和“下一个灯”应忽略不计!
N2S(false,null,null),N2E(false,null,null),W2E(false,null,null),W2N(false,null,null),
//应为向右方向的车不受控制,所以,可以假想它们总是绿灯
S2E(true,null,null),E2N(true,null,null),N2W(true,null,null),W2S(true,null,null);
private Lamp(boolean ligthed,String opposite , String next){
this.ligthed=ligthed;
this.opposite=opposite;
this.next=next;
}
// 设计灯,每条路线上对应的灯:true为绿,false为红灯
private boolean ligthed;
// 定义一个对应灯的变量 如S2N -> N2S
private String opposite;
// 表示此灯变绿后下一个变绿的灯
private String next ;
public static void main(String[] args) {
// TODO Auto-generated method stub
}
//判断灯状态,返回灯
public boolean isLighted(){
return ligthed;
}
//灯变亮的方法
public void light(){
this.ligthed=true;
if(opposite!=null){
((Lamp) Lamp.valueOf(opposite)).light();//返回枚举对应的名字对象
//opposite.light(); //对应灯
}
System.out.println(name() + " lamp is green,下面总共应该有6个方向能看到汽车穿过!");
}
// 灯熄灭变黑
public Lamp blackOut(){
this.ligthed=false;
if(opposite!=null){
Lamp.valueOf(opposite).blackOut();// 灯变黑
}
//我变黑了,要让下个灯变绿
Lamp nextLamp=null;
if(next!=null){
nextLamp = Lamp.valueOf(next);
System.out.println( name()+"变红!" + next +"下个变绿!");
nextLamp.light();
}
return nextLamp;
}
}
3.灯控制系统LampController 类的编写
分析:
1、整个系统中只能有一套交通灯控制系统,所以,LampController类最好是设计成单例。
2、LampController构造方法中要设定第一个为绿的灯。
3、LampController对象的start方法中将当前灯变绿,然后启动一个定时器,每隔10秒将当前灯变红和将下一个灯变绿。
package com.itheima.traffic;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import javax.swing.Timer;
public class LampController {
/**
* @param args
*/
// 当前为绿的灯
private Lamp currentLamp;
public LampController(){
currentLamp=Lamp.S2N;// 南到北
currentLamp.light();//亮
//启动一个定时器:每隔10秒将当前灯变红和下一个灯变绿
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run(){
System.out.println("交通运行开始啦!");
currentLamp = currentLamp.blackOut();
}
},
10,//每隔10秒变换
10,
TimeUnit.SECONDS);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
编写TestTraffic测试
package com.itheima.traffic;
public class TestTraffic {
/**
* @param args
*/
public static void main(String[] args) {
String[] directions = {"S2N","N2S","S2W","N2E","E2W","W2E",
"E2S","W2N","S2E","N2W","E2N","W2S"};
// 1、用for循环创建出代表12条路线的对象。
for(int i = 0 ; i < directions.length ; i ++) {
new Road(directions[i]) ;
}
//获取LampController对象并调用其start方法运行交通系统
new LampController() ;
}
}
打印结果:
N2S lamp is green,下面总共应该有6个方向能看到汽车穿过!
S2N lamp is green,下面总共应该有6个方向能看到汽车穿过!
E2N_1is running!
S2E_1is running!
W2S_1is running!
E2N_2is running!
S2N_1is running!
N2W_1is running!
W2S_2is running!
交通运行开始啦!
S2N变红!S2W下个变绿!
N2E lamp is green,下面总共应该有6个方向能看到汽车穿过!
S2W lamp is green,下面总共应该有6个方向能看到汽车穿过!
S2W_1is running!
N2E_1is running!
E2N_3is running!
N2E_2is running!
N2E_3is running!
S2E_2is running!
E2N_4is running!
S2E_3is running!
S2W_2is running!
N2W_2is running!
S2E_4is running!
S2W_3is running!
W2S_3is running!E2N_5is running!交通运行开始啦!
S2W变红!E2W下个变绿!
W2E lamp is green,下面总共应该有6个方向能看到汽车穿过!
E2W lamp is green,下面总共应该有6个方向能看到汽车穿过!
E2W_1is running!
W2E_1is running!
E2N_6is running!
E2W_2is running!
E2N_7is running!
W2E_2is running!
W2S_4is running!
E2W_3is running!
W2E_3is running!
N2W_3is running!
S2E_5is running!
W2S_5is running!
E2W_4is running!
W2E_4is running!
N2W_4is running!
交通运行开始啦!
总结:主要学会分析思路,没分析清楚是敲不出代码。
1.交通灯管理系统,先分清多少路线,东南西北四个方向,每个方向车都右向左、向右、直行的路线对象是路线,共12条。
2.不是定义车这个对象,不管是摩托车、还是汽车、车始终相当于路线合中的一个元素,路这个对象来控制车,关注的是路线方向。
3.线程管理中,产出都是一组线程,池来控制线程,那个空闲调用那个。
4.右拐弯的方向灯可不计影响看做全部绿灯,因为同一线路上前行灯是绿色通行的话,右方向的即可通行。
面向对象思想:路提供各个方向行驶的方法,谁拥有数据谁提供方法。
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流! -------------------------------
相关文章推荐
- 黑马程序员_面试题(1) 交通灯管理系统
- 黑马程序员_交通灯管理系统
- 黑马程序员—7k月薪面试题之交通灯管理系统
- 黑马程序员之交通灯管理系统
- 黑马程序员-----交通灯管理系统
- 【黑马程序员】Java7K面试题20:交通灯管理系统
- 黑马程序员——交通灯管理系统笔记
- 黑马程序员_7k面试题之交通灯管理系统
- 黑马程序员_交通灯管理系统
- 黑马程序员-交通灯管理系统分析
- 黑马程序员-交通灯管理系统(1)
- 黑马程序员--交通灯管理系统
- 黑马程序员-一种不同张孝祥老师视频中交通灯管理系统的实现
- 黑马程序员------交通灯管理系统
- 黑马程序员-交通灯管理系统
- 【黑马程序员】 java笔记——交通灯管理系统
- 黑马程序员-面试题(一)-交通灯管理系统
- 黑马程序员_交通灯管理系统思路整理
- 黑马程序员 交通灯管理系统
- 黑马程序员_ 学习日记_交通灯管理系统