黑马程序员_Java学习笔记之7K面试题交通等管理系统
来源:互联网 发布:淘宝给差评还能退货吗 编辑:程序博客网 时间:2024/05/17 05:13
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----
模拟十字路口的交通灯管理系统逻辑,具体需求如下
1. 异步随机生成按照各个路线行驶的车辆,例如:
由南向而来去往北向的车辆------直行车辆
由西向而来去往南向的车辆------右转车辆
由东向而来去往南向的车辆------左转车辆
①垂直向上。
②垂直向左拐。
③水平从东往西。
④从东往南。
2. 信号灯忽略黄灯,只考虑红灯和绿灯。
3. 应考虑左转车辆受信号灯控制,右转车辆不受信号灯控制。
4. 具体信号灯控制逻辑与现实中的普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑。注:南北向车辆与东西向车辆交替放行,同放行等待车辆应先放行直线车辆,而后放行左转车辆。如上图所示,若南往北绿灯(线路①S2N),北往南也为绿灯。当线路①为红灯时,N2S也为红灯,此时线路2(S2W)为绿灯。若东往西为绿灯(路线③E2W),西往东也为绿灯,当这两个方向为红灯后,线路④(E2S)为绿灯。
面向对象的思想剖析
设想一下有哪些对象:红绿灯,红绿灯的控制系统,汽车,路线。汽车看到自己所在路线对应的绿灯就穿过路口吗?不是,还需要看起前面是否有车辆,看前面是否有车,该文哪个对象呢?该问路,路中存储着车辆的集合,显然路中应该有增加车辆和减少车辆的方法。再看题目,这里并不需要体现车辆移动的过程,只是捕捉出车辆穿过马路的过程,也就是捕捉路上车辆减少的过程,所以,这个车并不需要单独设计成一个对象,用一个字符串表示即可。所以,有3个对象:路、红绿灯、红绿灯控制系统。
面向对象把握的一个重要的经验:谁拥有数据,谁就对外提供操作这些数据的方法。
交通灯控制系统的类的实现分析
每条路线上都会出现多辆车,路线上要随机增加新的车,在灯绿期间还要每秒钟减少一辆车。
设计一个Road类来表示路线,每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。
每条路线上随机增加新的车辆,增加到一个集合中保存。
每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
每条路线每隔一秒都会检查控制本路线的灯是否为绿,一个灯由绿变红时,应该将下一个方向的灯变绿。
设计一个Lamp类来表示一个交通灯,每个交通灯都维护一个状态:亮(绿)或不亮(红),每个交通灯要有变亮和变黑的方法,并且能返回自己的亮黑状态。
总共有12条路线,所以,系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制,但是为了让程序采用统一的处理方式,故假设出有四个右拐弯的灯,只是这些灯为常亮状态,即永远不变黑。
除了右拐弯方向的其他8条路线的灯,它们是两两成对的,可以归为4组,所以,在编程处理时,只要从这4组中各取出一个灯,对这4个灯依次轮询变亮,与这4个灯方向对应的灯则随之一同变化,因此Lamp类中要有一个变量来记住自己相反方向的灯,在一个Lamp对象的变亮和变黑方法中,将对应方向的灯也变亮和变黑。每个灯变黑时,都伴随者下一个灯的变亮,Lamp类中还用一个变量来记住自己的下一个灯。
无论在程序的什么地方去获得某个方向的灯时,每次获得的都是同一个实例对象,所以Lamp类改用枚举来做显然具有很大的方便性,永远都只有代表12个方向的灯的实例对象。
设计一个LampController类,它定时让当前的绿灯变红。
编写Road类中模拟汽车上路的代码
* 每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。
* 每条路线上随机增加新的车辆,增加到一个集合中保存。
// 路上的车辆
private List<String> vehiches = new ArrayList<String>();
private String name = null;//每条路线的名称
public Road(String name) {
this.name = name;
//创建线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
//执行任务,即从线程池中选择一个空闲线程执行该任务
pool.execute(new Runnable() {
public void run() {
//生成1000辆车
for(int i = 1; i <= 1000; i++) {
try {
//每隔随机的1~10秒钟,new Random().nextInt(10)返回0~9之间的随机数
//也就是每隔1~10秒钟随机生成一辆车
Thread.sleep((new Random().nextInt(10)+1) * 1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Road.this.name表示外部类Road的成员变量,
vehiches.add(Road.this.name+"_"+i);
}
}
});
//定时器
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//如果有车辆
if(vehiches.size() > 0) {
boolean lighter = Lamp.valueOf(Road.this.name).isLighted();
//假如灯是绿灯
if(lighter) {
System.out.println(vehiches.remove(0)+" is traversing !");
}
}
}
},
1, //经过1秒之后执行(执行邻上面的Runnable内部类里中内容)
1, //再过1秒接着执行
TimeUnit.SECONDS);//度量单位为:秒,表示上面的两个 1的单位都是秒钟
}
// 路上的车辆
private List<String> vehiches = new ArrayList<String>();
private String name = null;//每条路线的名称
public Road(String name) {
this.name = name;
//创建线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
//执行任务,即从线程池中选择一个空闲线程执行该任务
pool.execute(new Runnable() {
public void run() {
//生成1000辆车
for(int i = 1; i <= 1000; i++) {
try {
//每隔随机的1~10秒钟,new Random().nextInt(10)返回0~9之间的随机数
//也就是每隔1~10秒钟随机生成一辆车
Thread.sleep((new Random().nextInt(10)+1) * 1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Road.this.name表示外部类Road的成员变量,
vehiches.add(Road.this.name+"_"+i);
}
}
});
//定时器
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//如果有车辆
if(vehiches.size() > 0) {
boolean lighter = Lamp.valueOf(Road.this.name).isLighted();
//假如灯是绿灯
if(lighter) {
System.out.println(vehiches.remove(0)+" is traversing !");
}
}
}
},
1, //经过1秒之后执行(执行邻上面的Runnable内部类里中内容)
1, //再过1秒接着执行
TimeUnit.SECONDS);//度量单位为:秒,表示上面的两个 1的单位都是秒钟
}
// 路上的车辆
private List<String> vehiches = new ArrayList<String>();
private String name = null;//每条路线的名称
public Road(String name) {
this.name = name;
//创建线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
/*每个枚举元素各表示一个方向的控制灯*/
/*下面元素表示与上面的元素的相反方向的灯,它们的“相反方向灯”和“下一个灯”应忽略不计!*/
N2S(null,null,false) ,N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
//下面这4盏灯总是亮的
S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
private Lamp() {
}
private Lamp(String oppsite, String next,boolean lighted) {
this.oppsite = oppsite;
this.next = next;
this.lighted = lighted;
}
private boolean lighted;//是否亮灯,绿灯表示亮灯
private String oppsite;//对应方向的灯
private String next; //下一盏灯
//灯是否亮
public boolean isLighted() {
return lighted;
}
//点亮灯它对应方向的灯也要变绿
public void light() {
this.lighted =true;
//假如存在对应方向的灯
if(oppsite !=null) {
Lamp.valueOf(oppsite).light();//对应方向的灯也亮
}
//name方法返回此枚举常量的名称
System.out.println(name()+" lamp is green,下面总共有6个方向能看到汽车穿过马路");
}
//某个灯变红时,对应方向的灯也要变红,并且下一个方向的灯要变绿
public Lamp blackOut() {
this.lighted =false;
//假如存在对应方向的灯
if(oppsite !=null) {
//对应方向的灯熄灭
Lamp.valueOf(oppsite).blackOut();
}
//下一盏灯边亮
Lamp nextLamp = null;
if(next !=null) {
nextLamp = Lamp.valueOf(next);
System.out.println("绿灯从"+name()+" ------>切换为 "+next);
nextLamp.light();
}
return nextLamp;
}
}
交通灯控制器LampController类
public class LampController {
private Lamp currentLamp;
//构造方法
public LampController() {
currentLamp = Lamp.S2N;//当前灯为由南向北方向的
currentLamp.light();
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
//每隔10秒钟,让当前的灯变为红灯,并让下一个方向的灯变绿
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//当前的灯熄灭,并把下一盏变绿的灯复制给当前灯
currentLamp = currentLamp.blackOut();
}
},
10,
TimeUnit.SECONDS
);
}
public class MainClass {
public staticvoid main(String[] args) {
String[] directions = new String[] {
"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"
};
/*产生12个方向的路线*/
for(int i = 0; i < directions.length; i++) {
new Road(directions[i]);
}
/*产生整个交通灯系统*/
new LampController();
}
}
7K面试题—交通灯管理系统
交通都能管理系统项目需求模拟十字路口的交通灯管理系统逻辑,具体需求如下
1. 异步随机生成按照各个路线行驶的车辆,例如:
由南向而来去往北向的车辆------直行车辆
由西向而来去往南向的车辆------右转车辆
由东向而来去往南向的车辆------左转车辆
①垂直向上。
②垂直向左拐。
③水平从东往西。
④从东往南。
2. 信号灯忽略黄灯,只考虑红灯和绿灯。
3. 应考虑左转车辆受信号灯控制,右转车辆不受信号灯控制。
4. 具体信号灯控制逻辑与现实中的普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑。注:南北向车辆与东西向车辆交替放行,同放行等待车辆应先放行直线车辆,而后放行左转车辆。如上图所示,若南往北绿灯(线路①S2N),北往南也为绿灯。当线路①为红灯时,N2S也为红灯,此时线路2(S2W)为绿灯。若东往西为绿灯(路线③E2W),西往东也为绿灯,当这两个方向为红灯后,线路④(E2S)为绿灯。
面向对象的思想剖析
设想一下有哪些对象:红绿灯,红绿灯的控制系统,汽车,路线。汽车看到自己所在路线对应的绿灯就穿过路口吗?不是,还需要看起前面是否有车辆,看前面是否有车,该文哪个对象呢?该问路,路中存储着车辆的集合,显然路中应该有增加车辆和减少车辆的方法。再看题目,这里并不需要体现车辆移动的过程,只是捕捉出车辆穿过马路的过程,也就是捕捉路上车辆减少的过程,所以,这个车并不需要单独设计成一个对象,用一个字符串表示即可。所以,有3个对象:路、红绿灯、红绿灯控制系统。
面向对象把握的一个重要的经验:谁拥有数据,谁就对外提供操作这些数据的方法。
交通灯控制系统的类的实现分析
每条路线上都会出现多辆车,路线上要随机增加新的车,在灯绿期间还要每秒钟减少一辆车。
设计一个Road类来表示路线,每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。
每条路线上随机增加新的车辆,增加到一个集合中保存。
每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
每条路线每隔一秒都会检查控制本路线的灯是否为绿,一个灯由绿变红时,应该将下一个方向的灯变绿。
设计一个Lamp类来表示一个交通灯,每个交通灯都维护一个状态:亮(绿)或不亮(红),每个交通灯要有变亮和变黑的方法,并且能返回自己的亮黑状态。
总共有12条路线,所以,系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制,但是为了让程序采用统一的处理方式,故假设出有四个右拐弯的灯,只是这些灯为常亮状态,即永远不变黑。
除了右拐弯方向的其他8条路线的灯,它们是两两成对的,可以归为4组,所以,在编程处理时,只要从这4组中各取出一个灯,对这4个灯依次轮询变亮,与这4个灯方向对应的灯则随之一同变化,因此Lamp类中要有一个变量来记住自己相反方向的灯,在一个Lamp对象的变亮和变黑方法中,将对应方向的灯也变亮和变黑。每个灯变黑时,都伴随者下一个灯的变亮,Lamp类中还用一个变量来记住自己的下一个灯。
无论在程序的什么地方去获得某个方向的灯时,每次获得的都是同一个实例对象,所以Lamp类改用枚举来做显然具有很大的方便性,永远都只有代表12个方向的灯的实例对象。
设计一个LampController类,它定时让当前的绿灯变红。
编写Road类中模拟汽车上路的代码
* 每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。
* 每条路线上随机增加新的车辆,增加到一个集合中保存。
* 每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
public class Road {// 路上的车辆
private List<String> vehiches = new ArrayList<String>();
private String name = null;//每条路线的名称
public Road(String name) {
this.name = name;
//创建线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
//执行任务,即从线程池中选择一个空闲线程执行该任务
pool.execute(new Runnable() {
public void run() {
//生成1000辆车
for(int i = 1; i <= 1000; i++) {
try {
//每隔随机的1~10秒钟,new Random().nextInt(10)返回0~9之间的随机数
//也就是每隔1~10秒钟随机生成一辆车
Thread.sleep((new Random().nextInt(10)+1) * 1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Road.this.name表示外部类Road的成员变量,
vehiches.add(Road.this.name+"_"+i);
}
}
});
//定时器
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//如果有车辆
if(vehiches.size() > 0) {
boolean lighter = Lamp.valueOf(Road.this.name).isLighted();
//假如灯是绿灯
if(lighter) {
System.out.println(vehiches.remove(0)+" is traversing !");
}
}
}
},
1, //经过1秒之后执行(执行邻上面的Runnable内部类里中内容)
1, //再过1秒接着执行
TimeUnit.SECONDS);//度量单位为:秒,表示上面的两个 1的单位都是秒钟
}
// 路上的车辆
private List<String> vehiches = new ArrayList<String>();
private String name = null;//每条路线的名称
public Road(String name) {
this.name = name;
//创建线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
//执行任务,即从线程池中选择一个空闲线程执行该任务
pool.execute(new Runnable() {
public void run() {
//生成1000辆车
for(int i = 1; i <= 1000; i++) {
try {
//每隔随机的1~10秒钟,new Random().nextInt(10)返回0~9之间的随机数
//也就是每隔1~10秒钟随机生成一辆车
Thread.sleep((new Random().nextInt(10)+1) * 1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Road.this.name表示外部类Road的成员变量,
vehiches.add(Road.this.name+"_"+i);
}
}
});
//定时器
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//如果有车辆
if(vehiches.size() > 0) {
boolean lighter = Lamp.valueOf(Road.this.name).isLighted();
//假如灯是绿灯
if(lighter) {
System.out.println(vehiches.remove(0)+" is traversing !");
}
}
}
},
1, //经过1秒之后执行(执行邻上面的Runnable内部类里中内容)
1, //再过1秒接着执行
TimeUnit.SECONDS);//度量单位为:秒,表示上面的两个 1的单位都是秒钟
}
// 路上的车辆
private List<String> vehiches = new ArrayList<String>();
private String name = null;//每条路线的名称
public Road(String name) {
this.name = name;
//创建线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
//执行任务,即从线程池中选择一个空闲线程执行该任务
pool.execute(new Runnable() {
public void run() {
//生成1000辆车
for(int i = 1; i <= 1000; i++) {
try {
//每隔随机的1~10秒钟,new Random().nextInt(10)返回0~9之间的随机数
//也就是每隔1~10秒钟随机生成一辆车
Thread.sleep((new Random().nextInt(10)+1) * 1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Road.this.name表示外部类Road的成员变量,
vehiches.add(Road.this.name+"_"+i);
}
}
});
//定时器
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//如果有车辆
if(vehiches.size() > 0) {
boolean lighter = Lamp.valueOf(Road.this.name).isLighted();
//假如灯是绿灯
if(lighter) {
System.out.println(vehiches.remove(0)+" is traversing !");
}
}
}
},
1, //经过1秒之后执行(执行邻上面的Runnable内部类里中内容)
1, //再过1秒接着执行
TimeUnit.SECONDS);//度量单位为:秒,表示上面的两个 1的单位都是秒钟
}}
* 上面最后两行的灯是虚拟的,由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制,交通灯Lamp类的代码
* 每个Lamp元素代表一个方向上的灯,总共有12个方向,所有总共有12个Lamp元素。
* 有如下一些方向上的灯,每两个形成一组,一组灯同时变绿或变红,所以,
* 程序代码只需要控制每组灯中的一个灯即可:
* s2n,n2s
* s2w,n2e
* e2w,w2e
* e2s,w2n
* s2e,n2w
* e2n,w2s
* 所以,可以假想它们总是绿灯。
public enum Lamp {/*每个枚举元素各表示一个方向的控制灯*/
S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
/*下面元素表示与上面的元素的相反方向的灯,它们的“相反方向灯”和“下一个灯”应忽略不计!*/
N2S(null,null,false) ,N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
//下面这4盏灯总是亮的
S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
private Lamp() {
}
private Lamp(String oppsite, String next,boolean lighted) {
this.oppsite = oppsite;
this.next = next;
this.lighted = lighted;
}
private boolean lighted;//是否亮灯,绿灯表示亮灯
private String oppsite;//对应方向的灯
private String next; //下一盏灯
//灯是否亮
public boolean isLighted() {
return lighted;
}
//点亮灯它对应方向的灯也要变绿
public void light() {
this.lighted =true;
//假如存在对应方向的灯
if(oppsite !=null) {
Lamp.valueOf(oppsite).light();//对应方向的灯也亮
}
//name方法返回此枚举常量的名称
System.out.println(name()+" lamp is green,下面总共有6个方向能看到汽车穿过马路");
}
//某个灯变红时,对应方向的灯也要变红,并且下一个方向的灯要变绿
public Lamp blackOut() {
this.lighted =false;
//假如存在对应方向的灯
if(oppsite !=null) {
//对应方向的灯熄灭
Lamp.valueOf(oppsite).blackOut();
}
//下一盏灯边亮
Lamp nextLamp = null;
if(next !=null) {
nextLamp = Lamp.valueOf(next);
System.out.println("绿灯从"+name()+" ------>切换为 "+next);
nextLamp.light();
}
return nextLamp;
}
}
交通灯控制器LampController类
public class LampController {
private Lamp currentLamp;
//构造方法
public LampController() {
currentLamp = Lamp.S2N;//当前灯为由南向北方向的
currentLamp.light();
//定时器,只开启一个线程
ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
//每隔10秒钟,让当前的灯变为红灯,并让下一个方向的灯变绿
timer.scheduleAtFixedRate(
new Runnable() {
public void run() {
//当前的灯熄灭,并把下一盏变绿的灯复制给当前灯
currentLamp = currentLamp.blackOut();
}
},
10,
10,
TimeUnit.SECONDS
);
}
}
下面是MainClass主函数的编写public class MainClass {
public staticvoid main(String[] args) {
String[] directions = new String[] {
"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"
};
/*产生12个方向的路线*/
for(int i = 0; i < directions.length; i++) {
new Road(directions[i]);
}
/*产生整个交通灯系统*/
new LampController();
}
}
0 0
- 黑马程序员_Java学习笔记之7K面试题交通等管理系统
- 【黑马程序员】 学习笔记 - 直击7K面试题 - 张孝祥老师的交通等管理系统
- 黑马程序员——java面试题之交通等管理系统
- 黑马程序员高级视频学习笔记交通等管理系统
- 黑马程序员——学习笔记21.7K面试题之交通灯管理系统
- 黑马程序员--7K面试题之交通灯管理系统
- 黑马程序员----7k面试题之交通灯管理系统
- 黑马程序员-7K面试题之交通灯管理系统
- 黑马程序员-7k面试题之交通灯管理系统
- “黑马程序员”7k面试题之交通灯管理系统
- 黑马程序员_Java 7K面试题—交通灯管理系统
- 黑马程序员—Java基础学习笔记之7K月薪面试题破解_交通灯管理系统
- 黑马程序员----【张孝祥7K面试题】一交通灯管理系统视频学习笔记
- 【黑马程序员】 学习笔记 - 直击7K面试题 - 张孝祥老师的银行业务调度管理系统
- 黑马程序员--高薪面试题交通信号灯管理系统
- 黑马程序员——冲刺阶段——7K面试题(交通信号灯系统)
- 黑马程序员---七千面试题之交通灯管系统
- 黑马程序员--Java学习247K面试题之交通灯管理系统
- JSP九大内置对象及四个作用域
- Microsoft Visual Studio
- js 数组合并 分隔 及转为json格式
- 电池供电设备的电池容量的选择
- uboot启动后在内存中运行裸机程序hello
- 黑马程序员_Java学习笔记之7K面试题交通等管理系统
- 实现表格列表显示图片名称,点击可下载
- adb调试配置
- JscrollPane控制滚动条自动滚到底部
- linux中的vim的几个基本操作(二)
- java分页导航生成工具
- Java反射机制详解
- ubuntu navicat110 for mysql 装配与破解
- sql2005无法查看数据库属性:在位置 0 处没有任何行。 (System.Data)