黑马程序员—交通灯管理系统

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

一、 模拟实现十字路口的交通灯管理系统逻辑,具体需求如下:
Ø 异步随机生成按照各个路线行驶的车辆。

例如:

由南向北的车辆 ---- 直行车辆

由西向南的车辆 ---- 右转车辆

由东向南的车辆 ---- 左转车辆

。。。

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

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

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

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

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

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

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

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

1.场景分析:

A.十字路口有两条道路,每条道路有两个方向,每个方向又分直行、向左行和向右行,所以总共有12条路线。如图:


B.方向相对的路线的灯总是同时为绿灯或红灯,所以只需要考虑一个方向,因此需要考虑的路线减少为6条。
C.又因为向右行驶的的车辆不受交通灯的影响,所以只需要考虑直行方向和向左行驶的方向,因此最终需要考虑的路线只有4条。
D.根据以上分析,以从南、东行驶过来的方向为基准,即只需考虑南——>北、南——>西、东——>西、东——>南四条路线。

2.与业务相关的对象,显然只有交通灯、道路(12条路)、车、交通灯控制系统。

3.为了统一编程模型,假设每条路线都有一个交通灯,只不过向右行驶的交通灯总是绿色的。

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

A.设计一个Road类,每个Road对象代表一条路线,总共有12条路线,即系统中总共有12个Road对象。
B.每个Road对象内保存一个集合,用于保存路线上随机增加新的车。
C.每个Road对象每隔1秒钟要检查自己所对应的灯是否为绿灯,若为绿灯,该路线每秒减少1辆车,表示这辆车穿过路口。

5.设计一个Lamp类。

A.每条路线都有一个Lamp对象(灯),总共有12个灯,可以变绿或变红。
B.四条基准路线对应的灯负责将自己变绿或变红。
C.当前灯变绿时,通知相对路线的灯变绿。
D.当前灯变红时,通知相对路线的灯变红,通知下一个路线的灯变绿。

6.交通灯控制系统每个10秒钟,通知当前绿灯变为红灯。

三、编写程序。

Road类的编写:
1.每个Road对象都有一个name成员变量来代表方向,与该路线对应的灯对象名相同,便于访问该路线的灯,有一个vehicles成员变量来代表方向上的车辆集合。
2.在Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车(用一个“路线名_id”形式的字符串进行表示)。
3.在Road对象的构造方法中启动一个定时器,每隔一秒检查该方向上的灯是否为绿,是则打印车辆集合和将集合中的第一辆车移除掉,表示有车穿过路口。

package com.isoftstone.interview.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;  

/**
 * 每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。
 * 每条路线上随机增加新的车辆,增加到一个集合中保存。
 * 每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
*/
public class Road {
    //代表一个队列集合,先进先出,即在前面的车辆先过路口
    private List<String> vechicles = 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(){
                for(int i=1;i<1000;i++){
                    try {
                        Thread.sleep((new Random().nextInt(10) + 1) * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //表示该路线有车行驶过来
                    vechicles.add(Road.this.name + "_" + i);
                }
            }  

        });  

        //每隔一秒检查对应的灯是否为绿,是则放行一辆车
        ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
        timer.scheduleAtFixedRate(
                new Runnable(){
                    public void run(){
                        if(vechicles.size()>0){
                            //获取该路线灯的状态
                            boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
                            if(lighted){
                                //是绿灯,穿过一辆车
                                System.out.println(vechicles.remove(0) + " is traversing !");
                            }
                        }  

                    }
                },
                1,
                1,
                TimeUnit.SECONDS);  

    }
}  

Lamp类的编写:
12条路线就有12个灯,每条路线根据灯的名字获取对应的灯对象,因此考虑使用枚举更简单。

1.灯的绿、红状态应该有个属性(lighted)保存

2.变绿、变红通过light()、setBlackOut()方法实现

3.当前灯还应该指引着相对的灯(属性opposite)的状态与自己的相同

4.当前灯变红时,通知下一个灯(属性next)变绿。

package com.isoftstone.interview.traffic;  

/**
 * 每个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),
    /*由南向东和由西向北等右拐弯的灯不受红绿灯的控制,所以,可以假想它们总是绿灯*/
    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;
    public boolean isLighted(){
        return lighted;
    }  

    /**
     * 某个灯变绿时,它对应方向的灯也要变绿
     */
    public void light(){
        this.lighted = true;
        if(opposite != null){
            Lamp.valueOf(opposite).light();
        }
        System.out.println(name() + " lamp is green,下面总共应该有6个方向能看到汽车穿过!");  

    }  

    /**
     * 某个灯变红时,对应方向的灯也要变红,并且下一个方向的灯要变绿
     * @return 下一个要变绿的灯
     */
    public Lamp blackOut(){
        this.lighted = 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;
    }
}  

LampController类的编写:
1.整个系统中只能有一套交通灯控制系统,所以,LampController类最好是设计成单例。

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

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

package com.isoftstone.interview.traffic;  

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;  

public class LampController {
    private Lamp currentLamp;  

    public LampController(){
        //初始时让由南向北的灯变绿;
        currentLamp = Lamp.S2N;
        currentLamp.light();  

        /*每隔10秒将当前绿灯变为红灯,并让下一个方向的灯变绿*/
        //一个定时器
        ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
        timer.scheduleAtFixedRate(
                new Runnable(){
                    public  void run(){
                        //时间到将当前灯变红,并将下一个灯变绿,当前灯始终是绿的
                        currentLamp = currentLamp.blackOut();
                }
                },
                10,
                10,
                TimeUnit.SECONDS);
    }
}  

MainClass类的编写:

1.用for循环创建出代表12条路线的对象。
2.接着再获得LampController对象并调用其start方法启动交通灯控制系统。

package com.isoftstone.interview.traffic;  

public class MainClass {  

    public static void main(String[] args) {  

        /*产生12个方向的路线*/
        String [] directions = new String[]{
                "S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"
        };
        for(int i=0;i<directions.length;i++){
            new Road(directions[i]);
        }  

        /*产生整个交通灯系统*/
        new LampController();
    }  

}  
时间: 2024-10-17 19:00:09

黑马程序员—交通灯管理系统的相关文章

黑马程序员——交通灯管理

模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 异步随机生成按照各个路线行驶的车辆. 例如: 由南向而来去往北向的车辆 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 ... 信号灯忽略黄灯,只考虑红灯和绿灯. 应考虑左转车辆控制信号灯,右转车辆不受信号灯控制. 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑. 注:南北向车辆与东西向车辆交替放行,同方向等待车辆应先放行直行车辆而后放行左转车辆. 每辆车通过路口时间为1秒(提示:可通过线程Sleep

黑马程序员-交通灯系统

要求: 异步随机生成按照各个路线行驶的车辆. 例如: 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 信号灯忽略黄灯,只考虑红灯和绿灯. 应考虑左转车辆控制信号灯,右转车辆不受信号灯控制. 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑. 注:南北向车辆与东西向车辆交替放行,同方向等待车辆应先放行直行车辆而后放行左转车辆. ?每辆车通过路口时间为1秒(提示:可通过线程Sle

黑马程序员--交通灯管理

模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 异步随机生成按照各个路线行驶的车辆. 例如: 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 ... 信号灯忽略黄灯,只考虑红灯和绿灯. 应考虑左转车辆控制信号灯,右转车辆不受信号灯控制. 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑. 注:南北向车辆与东西向车辆交替放行,同方向等待车辆应先放行直行车辆而后放行左转车辆

黑马程序员——交通信号灯管理系统

题目: 模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 异步随机生成按照各个路线行驶的车辆. 例如: 由南向而来去往北向的车辆 右转车辆 由东向而来去往南向的车辆"); } public Lamp blackOut(){ this.lighted = false; if(opposite!=null){ Lamp.valueOf(opposite).blackOut(); } Lamp nextLamp = null; if(next!=null){ nextLamp = Lamp.val

黑马程序员_交通灯管理系统

(1)项目的需求 模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 例如: 由南向而来去往北向的车辆 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 平时开车过十字路口红绿灯的时候,也知道红绿灯运行的顺序 (1)任何方向的车,向右边转弯的时候,是不需要看红绿灯 (2)在十字路口,相对方向的红绿灯的工作方式是一样的,南相对与北,东相对与西,这把它分成两对 (3)红绿灯顺序,一对直行通道绿灯直行车辆,等直行变红,还是这对的车辆可以左转,等左转变红,就轮到下一对了.所以在设计程序的时候,只

黑马程序员-java 7K面试题之交通灯管理系统

------- android培训.java培训.期待与您交流! -------- 交通灯管理系统 模拟实现十字路口的交通灯管理系统逻辑,具体需求如下: 1. 异常随机生成按照各个路线行驶的车辆. 例如: 由南向而来去往北向的车辆----直行车辆 由西向而来去往南向的车辆----右转车辆 由东向而来去往南向的车辆----左转车辆 .......  ...... 2. 信号灯忽略黄灯,只考虑红灯和绿灯. 3. 应该考虑左转车辆控制信号灯,右转车辆不受信号灯控制. 4. 具体信号灯控制逻辑与现实

黑马程序员——【Java高新技术】——案例:交通灯管理系统

一.交通灯管理系统的项目需求 Ø 异步随机生成按照各个路线行驶的车辆 例如: 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 …… Ø 信号灯忽略黄灯,只考虑红灯和绿灯. Ø 应考虑左转车辆控制信号灯,右转车辆不受信号灯控制. Ø 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑. 注:南北向车辆与东西向车辆交替放行,同方向等待车辆应先放行直行车辆,而后放行左转车辆. Ø 每

黑马程序员_JAVA之交通灯管理系统

1.一.需求:模拟实现十字路口的交通灯管理系统逻辑,具体需求如下:  1.异步随机生成按照各个路线行驶的车辆.     例如:     由南向而来去往北向的车辆 右转车辆     由东向而来去往南向的车辆 ---- 左转车辆     ......  2.信号灯忽略黄灯,只考虑红灯和绿灯.  3.应考虑左转车辆控制信号灯,右转车辆不受信号灯控制.  4.具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑.     注:南北向车辆与东西向车辆交替放行,同方向等待车辆应先

黑马程序员___交通灯管理系统

----------- android培训.java培训.java学习型技术博客.期待与您交流! --------- 交通灯管理系统的项目需求 异步随机生成按照各个路线行驶的车辆. 例如: 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 ... 信号灯忽略黄灯,只考虑红灯和绿灯. 应考虑左转车辆控制信号灯,右转车辆不受信号灯控制. 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制