黑马程序员—7k月薪面试题之交通灯管理系统

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

交通灯管理系统需求：

模拟实现十字路口的交通灯管理系统逻辑，具体需求如下：

Ø 异步随机生成按照各个路线行驶的车辆。

例如：

由南向而来去往北向的车辆----直行车辆

由西向而来去往南向的车辆 ----右转车辆

由东向而来去往南向的车辆 ----左转车辆

。。。

Ø 信号灯忽略黄灯，只考虑红灯和绿灯。

Ø 应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。

Ø 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。

注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

Ø 每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。

Ø 随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

Ø 不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

一、思路分析：

* 想想自己最熟悉的一个十字路口，可以好好回忆十字路口上的红绿灯和车辆是如何运作的。

* 为了帮助记忆和理解，对十字路口上的红绿灯和车辆详细的运行状况进行分析，所以要自己动手画一张图片，这样就不至于

* 大脑思考时间一长，思维混乱了。

* 在Native2Ascii和DOM4j工具中，2表示是to的简写，我想因为2在英语中的读音是two，和to读音相同吧。

* 4表示是for，同样的因为4的英语读音是four，和for相同的原因。这是程序员圈子里对to和for简写的习惯。

* 所以在画图中，我们也用这些简写，使图片看起来更加简洁，一目了然。

* 图中一共有从四个方向来的车辆，每个方向来的车辆都有3个方向可以行驶。分别是直行、向左拐弯、和向右拐弯。

* 所以图中一共有12条行驶路线。为了方便于观看，图中同一个方向来的车辆可以行驶的3条线路为同一种颜色。

* 从南方向来的车辆可以行驶的线路分别是南到北(S2N) 南到西(S2W) 南到东(S2E)

* 从东方向来的车辆可以行驶的线路分别是东到西(E2W) 东到南(E2S) 东到北(E2N)

* 从北方向来的车辆可以行驶的线路分别是北到南(N2S) 北到东(N2E) 北到西(N2W)

* 从西方向来的车辆可以行驶的线路分别是西到东(W2E) 西到北(W2N) 西到南(W2S)

* 为了方便于思考：我们可以简化整个红绿灯的运作过程，当我们考虑一个方向的直行车辆时，对面方向来的直行车辆可以不用考虑了。

* 当我们考虑一个方向的向左拐弯车辆时，对面方向的车辆也必然是要向它所在的方向向左拐弯。

* 因为他们是对应的，当S方向的车辆向对面N方向直行，那么对面N方向的车辆必然是向S方向直行的。

* 当S方向车辆向左边W拐弯，那么与S方向对应的N方向要向N所在的左边拐弯，也就是向E拐弯。

* 其他方向的也是同理。

* 而每个方向的车辆向右拐弯时是没有红绿灯限制的，不用考虑到他们的线路情况，所以我们把整体所有的行驶线路简化为4条。

* 即南到北(S2N) 南到西(S2W) 东到西(E2W) 东到南(E2S)

* 12条线路，为了统一编程模型，我们可以假设每条线路都有一个红绿灯控制，上面已经说到，每个方向向右行驶的车辆，他们没有红绿灯

* 限制，就是说，可以假设这4条线路是绿灯一直常亮着。另外的8条线路都是两两成对，所以程序中只考虑图中标注的 ① ② ③ ④ 这四条线路上

* 的红绿灯切换的顺序。而这四条线路相反方向的红绿灯，是跟随着这四条线路的红绿灯一起切换的，所以不用额外考虑。

* 十字路口上红绿灯和车辆行驶的基本运行逻辑：

* 1.假如此刻南向北(S2N)方向为绿灯亮起，同样，此刻北向南(N2S)方向的也必然是绿。那么，南向北和北向南方向车辆可以直行了。

* 2.当南向北(S2N)和北向南(N2S)方向控制灯变为红灯时，那么，南向西(S2W)和北向东(N2E)这两个线路的灯变为绿色，这两个线路的车辆可以行驶了。

* 3.当南向西(S2W)和北向东(N2E)方向控制灯变为红灯时，那么，东向西(E2W)和西到东(W2E)这两线路必然是绿灯，他们可以行驶了。

* 4.当东向西(E2W)和西到东(W2E)方向变为红灯时，那么，东到南(E2S)和西到北(W2N)这两条线路必然是绿灯，他们可以行驶了

* 5.当东到南(E2S)和西到北(W2N)方向变为红灯时，那么，又会切换到南向北(S2N)和北向南(N2S)方向为绿灯，如此循环，这就是十字路口，

* 红绿灯和车辆之间运作的基本情况了。

* 二、面向对象的分析与设计：

* 1.我们有哪些对象呢？

* 红绿灯对象、红绿灯的控制器对象(负责把某个灯变绿把另外一个灯变红的对象，该对象控制了4组灯)、还有路线对象。

* 2.汽车看到自己所在路线上的灯只要是绿色就要通过该路线吗？现实生活中，当然不是这样，我们肯定要看前面是否有车.看前面是否有车，要看哪个对象呢？

* 要问路线的对象，我们要这么想，路线对象相当于集合，这个集合中放了好多车辆对象。所以我们要问路线对象。而路线对象里面已经有增加车辆和减少车辆的方法。

* 结合题目来看，我们并不需要捕捉车辆的移动和其他更多的过程，我们只需要捕捉车辆通过路线的过程，也就是捕捉路线上减少一辆车的过程，所以车并不需要设计

* 成为一个单独的对象，可以用字符串表示车。

* 3.那么，有几个灯的实例对象呢？

* 一共有12个灯的实例对象，代表着12条线路。每个方向的右拐弯在生活中是没有灯的，但是在程序中，为了统一编程模型，我们可以假设这4条线路也都是有灯的，但这4个灯是常绿状态。

* 对于十字路口，永远都只有12个灯，就是说永远都只有12个固定的实例对象，不能再new出新的实例对象，所以，我们可以用枚举来创建这12个固定的实例对象。

* 这12个红绿灯对象中，向右转弯的四条线路上的4个灯为常绿状态。另外8个灯，他们是两两相对的。所以我们只需要考虑4组灯的切换。所以在程序中我们只设计4个灯。

* 这4个灯都是有逻辑的，因为灯只有两种状态，所以我们可以设计为当灯变绿即为灯变亮了，灯变红即为灯熄灭了。

* 当一个方向上的灯变亮(绿)，那么就要把对应相反方向线路上的灯也变亮。

* 当这个灯熄灭(变红)，那么就要把对应相反方向线路上的灯也变红。然后，把下一个方向线路上的灯要变绿。

* 所以灯的类里有3个变量，分别是自己的灯、相反方向的灯、还有下一个路线上的灯。

* 4.红绿灯控制器类：

* 控制系统里面要有一个变量，记录当前是哪一个灯为亮的。它里面有一个定时器，限定的时间一到，就要把这个灯变为红色(熄灭)。

* 这个灯变为红色了，变红的方法就要返回下一个灯。定时器就要记录下一个变绿的灯了。

* 3.面向对象设计的经验：谁拥有数据，谁就对外提供操作这些数据的方法。因为数据一般都是某个对象私有的，所以这个对象必定要提供操作这些数据的方法。

* 请牢牢的掌握以下案例：

* ①.人在黑板上画圆。其中包含了3个对象，Person,Blackboard,circle,而画圆这个方法需要的圆心(x, y) x、y坐标表示圆心坐标。还需要半径radius

* 圆心和半径都是圆的属性，画圆的方法要操作这两个属性，所以画圆的这个方法也是属于圆的方法。

* ②.汽车司机紧急刹车。其中包含了汽车对象和司机对象。刹车方法中要操作车子的刹车系统，离合器分离，刹车片摩擦刹车盘这些都是汽车自己有的属性，所以刹车方法也是属于汽车这个对象的。

* ③.售票员统计票据的金额，其中包含了售票员对象和票据对象。统计票据金额的方法要操作票据上的商品数量和商品单价，而这些属性也都是票据身上的，所以统计票据方法是属于票据的。

* 而售票员只是调用了它的这个getTotalMoney()方法，这个方法的内部会计算出票据内部的总金额。

* ④.你把门关上了。其中包含了你对象，还有门对象。关门这个动作属于谁的方法？属于门的，你只是调用了门的这个关门的方法，门的关门方法内部会操作门转动多少角度、撞到门框后伸出锁舌。

* 面试题：两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材可以做成椅子。

* 这里面包含的对象：Stone石头、StoneKnife石刀对象、Tree树对象、Wood木材对象、Chair椅子对象

* StoneKnife = KnifeFactory.createKnife(Stone first, Stone second);

* Wood= StoneKnife.cut(tree);

* Chair= ChairFactory.makeChair(wood);

程序类的编写：

每条路线上都会出现多辆车，路线上要随机增加新的车，在灯绿期间还要每秒钟减少一辆车。

设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。

每条路线上随机增加新的车辆，增加到一个集合中保存。

每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。

每条路线每隔一秒都会检查控制本路线的灯是否为绿，一个灯由绿变红时，应该将下一个方向的灯变绿。

设计一个Lamp类来表示一个交通灯，每个交通灯都维护一个状态：亮（绿）或不亮（红），每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。

总共有12条路线，所以，系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。

除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮询变亮，与这4个灯方向对应的灯则随之一同变化，因此Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随者下一个灯的变亮，Lamp类中还用一个变量来记住自己的下一个灯。

无论在程序的什么地方去获得某个方向的灯时，每次获得的都是同一个实例对象，所以Lamp类改用枚举来做显然具有很大的方便性，永远都只有代表12个方向的灯的实例对象。

设计一个LampController类，它定时让当前的绿灯变红。

Road类的编写:

每个Road对象都有一个name成员变量来代表方向，有一个vehicles成员变量来代表方向上的车辆集合。

在Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车（用一个“路线名_id”形式的字符串进行表示）。

在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 {//定义一个集合，用于存放车辆List<String> vehicles = new ArrayList<String>();//定义属性，路的名字private String roadName = null;//构造函数，当新建一个路线对象时，就传入路线的名字public Road(String roadName) {//给路线名字赋值this.roadName = roadName;//创建一个线程池ExecutorService pool = Executors.newSingleThreadExecutor();//向这个线程池提交一个需要执行的任务pool.execute(new Runnable() {//run方法里面就是要线程执行的任务public void run() {//循环给路上添加999辆车for (int i = 1; i < 1000; i++) {try {//线程sleep 1秒到10秒之间的随机时间再执行下一步操作Thread.sleep((new Random().nextInt(10) + 1) * 1000);//处理异常} catch (InterruptedException e) {e.printStackTrace();}//内部类要访问外部类的成员变量，外部类名.this.外部类的成员变量名//添加车辆代码vehicles.add(Road.this.roadName + "--the--" + i + "--car is throughing..");}}});//定时器ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);//定时器定义固定不变的频率方法，传入参数需要执行的任务、等待执行任务的时间、执行完任务再过多长时间、时间的计量单位timer.scheduleAtFixedRate(new Runnable() {//run方法里面为要执行的任务public void run() {//检查集合里面是否有车辆，如果集合不为空，就表示有车辆，那么才能执行下一行代码if (!(vehicles.isEmpty())) {boolean lighted = Lamp.valueOf(Road.this.roadName).isLighted();if (lighted) {//移除第一辆车，并打印提示信息System.out.println(vehicles.remove(0));}}}},1,//等待执行任务的时间，过多少时间执行任务1,//执行完任务再过多长时间TimeUnit.SECONDS);//时间的计量单位 SECONDS(秒)}
}

Lamp类的编写:

系统中有12个方向上的灯，在程序的其他地方要根据灯的名称就可以获得对应的灯的实例对象，综合这些因素，将Lamp类用java5中的枚举形式定义更为简单。

每个Lamp对象中的亮黑状态用lighted变量表示，选用S2N、S2W、E2W、E2N这四个方向上的Lamp对象依次轮询变亮，Lamp对象中还要有一个oppositeLampName变量来表示它们相反方向的灯，再用一个nextLampName变量来表示此灯变亮后的下一个变亮的灯。这三个变量用构造方法的形式进行赋值，因为枚举元素必须在定义之后引用，所以无法再构造方法中彼此相互引用，所以，相反方向和下一个方向的灯用字符串形式表示。

增加让Lamp变亮和变黑的方法：light和lightingOff，对于S2N、S2W、E2W、E2N这四个方向上的Lamp对象，这两个方法内部要让相反方向的灯随之变亮和变黑，lightingOff方法还要让下一个灯变亮。

除了S2N、S2W、E2W、E2N这四个方向上的Lamp对象之外，其他方向上的Lamp对象的nextLampName和oppositeLampName属性设置为null即可，并且S2N、S2W、E2W、E2N这四个方向上的Lamp对象的nextLampName和oppositeLampName属性必须设置为null，以便防止light和lightingOff进入死循环。

代码体现：

package com.itheima.traffic;//交通灯枚举类
public enum Lamp {//有交通灯控制的为8条线路，程序中只要控制住这四条线路的交通灯，另外四条相反方向的交通灯会和这4条线的交通灯一起变化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),//这四条线路上不受交通灯控制，本程序不用对他们进行单独控制，把他们设置为常绿即可。S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2s(null,null,true);private Lamp(String opposite, String next, boolean lighted) {this.opposite = opposite;this.next = next;this.lighted = lighted;}//灯亮或者不亮的变量private boolean lighted;//反方向路线的灯private String opposite;//下一个路线的灯private String next;//boolean型的javaBean的get方法要设置为is，这个方法返回灯亮或者不亮public boolean isLighted() {return lighted;}//让灯变绿的方法，设置灯亮起public void light() {this.lighted = true;//如果有对应的灯if (opposite != null) {//就让他对应的那个灯亮起Lamp.valueOf(opposite).light();}System.out.println(name()+"-->Traffic lamp is green!");}//让灯变红的方法，设置灯熄灭public Lamp lightingOff() {this.lighted = false;//如果有对应的灯if (opposite != null) {//就把对应的灯熄灭Lamp.valueOf(opposite).lightingOff();}Lamp nextLamp =null; //如果有下一个灯if (next != null) {nextLamp = Lamp.valueOf(next);System.out.println("---------------------------------------");System.out.println("Green lamp from--"+name()+"--to--"+next);//那么就把下一个灯变亮nextLamp.light();}return nextLamp;}
}

LampController类的编写:

整个系统中只能有一套交通灯控制系统，所以，LampController类最好是设计成单例。

LampController构造方法中要设定第一个为绿的灯。

LampController对象的start方法中将当前灯变绿，然后启动一个定时器，每隔10秒将当前灯变红和将下一个灯变绿。

代码体现：

package com.itheima.traffic;import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;//交通灯控制器类
public class LampController {//当前灯属性private Lamp currentLamp;//构造函数，初始化当前灯为 S2N 线路上的灯，并点亮它public LampController() {currentLamp = Lamp.S2N;currentLamp.light();//定时器ScheduledExecutorService timer =Executors.newScheduledThreadPool(1);//定时器定义固定不变的频率方法timer.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {currentLamp = currentLamp.lightingOff();}},10,10,TimeUnit.SECONDS);}
}

MainClass类的编写:

用for循环创建出代表12条路线的对象。

接着再获得LampController对象并调用其start方法。

代码体现：

package com.itheima.traffic;//程序主函数
public class MainClass {public static void main(String[] args) {//把12条线路所表示的字符串添加进一个字符串数组String[] directions ={"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();}
}

程序运行截取的部分结果：

N2S-->Traffic lampis green!

S2N-->Traffic lampis green!

N2S--the--1--car isthroughing..

S2N--the--1--car isthroughing..

E2N--the--1--car isthroughing..

N2W--the--1--car isthroughing..

N2S--the--2--car isthroughing..

S2E--the--1--car isthroughing..

W2s--the--1--car isthroughing..

---------------------------------------

Green lampfrom--S2N--to--S2W

N2E-->Traffic lampis green!

S2W-->Traffic lampis green!

N2E--the--1--car isthroughing..

S2W--the--1--car is throughing..

S2W--the--2--car isthroughing..

E2N--the--2--car isthroughing..

W2s--the--2--car isthroughing..

N2E--the--2--car isthroughing..

N2W--the--2--car isthroughing..

W2s--the--3--car isthroughing..

N2W--the--3--car isthroughing..

N2E--the--3--car isthroughing..

S2E--the--2--car isthroughing..

S2W--the--3--car isthroughing..

N2E--the--4--car isthroughing..

E2N--the--3--car isthroughing..

---------------------------------------

Green lampfrom--S2W--to--E2W

W2E-->Traffic lampis green!

E2W-->Traffic lampis green!

W2E--the--1--car isthroughing..

W2s--the--4--car isthroughing..

E2W--the--1--car isthroughing..

W2E--the--2--car isthroughing..

E2W--the--2--car isthroughing..

S2E--the--3--car isthroughing..

W2E--the--3--car is throughing..

E2W--the--3--car isthroughing..

W2E--the--4--car isthroughing..

E2W--the--4--car isthroughing..

W2E--the--5--car isthroughing..

E2W--the--5--car isthroughing..

N2W--the--4--car isthroughing..

W2E--the--6--car isthroughing..

E2N--the--4--car isthroughing..

E2N--the--5--car isthroughing..

S2E--the--4--car isthroughing..

S2E--the--5--car isthroughing..

W2s--the--5--car isthroughing..

---------------------------------------

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

黑马程序员—7k月薪面试题之交通灯管理系统相关推荐

黑马程序员--7K面试题--交通灯管理系统
-------android培训.java培训.期待与您交流! ---------- 一.交通灯管理系统项目需求: 模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 1.异步随机生成按照各个路线行 ...
黑马程序员_7K面试题之交通灯管理系统
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 交通灯管理系统题目要求模拟实现十字路口的交通灯管理系统逻辑,具体需求如: 1.异步随机生成按 ...
黑马程序员——收集起来的ios笔试题——黑马 ios 技术博客
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 面试能力要求:精通iphone的UI开发,能熟练操作复杂表视图,熟练使用图层技术, 可以自定义U ...
黑马程序员-java就业面试题大全（持续更新）
1.一个"java"源文件中是否可以包含多个类(不是内部类)?有什么限制? 可以有多个类,但只能有一个是public 类,并且public类名必须与文件名一致. 2.java中有没 ...
黑马程序员_面试题(一)交通灯管理系统
android培训.java培训.期待与您交流! [Road类]: 每个Road对象都有一个name成员变量来代表方向,有一个vehicles成员变量来代表方向上的车辆集合. 在Road对象的构造方法 ...
黑马程序员C++实战(二)——基于多态的职工管理系统完整代码
本文转载自:https://github.com/AnkerLeng/Cpp-0-1-Resource.git 视频见:https://www.bilibili.com/video/av4155972 ...
（黑马程序员）MongoDB + Express + art-template 项目实例-博客管理系统第一页
1.项目环境搭建 1.1.项目介绍多人博客管理系统: 1.博客内容展示 2.博客管理功能 1.2.项目初始化 1.建立项目所需文件夹: ● public 静态资源 ● model 数据库操作 ● r ...
黑马程序员入学Java知识——精华总结
黑马程序员入学Java知识--精华总结 J2SE部分,Java高新技术部分,7K面试题部分等黑马入学要求的知识点总结! 一.黑马程序员-java概述与基础知识 6 1.何为编程? 6 2.Java语言 ...
黑马程序员--银行以及交通系统项目个人理解
----------------------------------------7K面试题之交通灯管理系统---------------------------------------- 项目需求: ...

黑马程序员—7k月薪面试题之交通灯管理系统

黑马程序员—7k月薪面试题之交通灯管理系统相关推荐

最新文章

热门文章