[one_demo_15]模拟交通灯管理系统

末蓝、 2022-04-22 07:40 250阅读 0赞

项目需求

模拟实现十字路口的交通灯管理系统逻辑。

1.  异步随机产生各个路线上行走的车辆。例如，由南向北的直行车辆，由南向西的左转车辆，由南向东的右转车辆。
2.  信号灯忽略黄灯，只考虑红灯和绿灯。
3.  需考虑左转车辆受信号灯控制，右转车辆不受信号灯控制。
4.  信号灯的具体的控制逻辑与现实中的情况一致，不考虑特殊情况。南北向车辆和东西向车辆交替放行，同方向车辆，先放行直行车辆再放行左转车辆。
5.  每辆车过路口的时间为1秒，可以使用sleep模拟。
6.  随机生成车辆时间和交通灯切换时间自定义。

需求分析

为了便于分析，可以画十字路口的图帮助分析。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd6aGlzaGVu_size_16_color_FFFFFF_t_70][]

面向对象分析和设计

1，分析十字路口图，两条路，4个大方向，每个大方向产生3个细分方向，一共有12个方向，那么就需要12个灯。车辆在线路上行驶，车辆的产生和通过由线路控制。

2，系统涉及到3个类，交通灯，线路，交通灯管理器。

3，线路类，12个方向，需要12个线路对象，每个线路对象有一个name表示这个线路的方向，由于车辆不需要考察车的属性和车本身的方法，所以，线路中的车以字符串表示，车的增加和通过路口就使用一个集合模拟队列的先进先出实现。每条线路每隔一秒检查本线路的灯是否为绿，如果绿灯，则将线路车辆集合中的第一辆放行过路口。

4，交通灯类，一共有12个灯是固定的，采用枚举类型比较方便，12个方向的灯，枚举类型设置判断灯是否绿的方法，将红灯转绿灯的方法，将绿转为红灯的方法，本灯下个灯的方法和设置每个枚举属性值的构造方法。对于12个方向灯，分析其特点，其中4个右转的方向是不受灯控制的，为了便于编程，将这个4个灯设置为常绿；另外8组方向，当一个方向绿时，其反方向必然也为绿，可以将这8组，看作两个4组，其中一组受到另外一组的控制，需要一个反方向变量来表示器反方向，拿出来其中的一个4组方向，定时对这4个方向做轮询，比如一个方向变红后，那么其下一个方向就变绿，并且返回这个变绿的方向以便操作。

5，交通灯管理器类，整个系统中只有一个交通灯管理器，这个类要设计为单例。交通灯管理器启动一个计划线程，每隔10秒将一个灯变红，并将下一个灯变绿。

6，main类，测试类，for循环出12条路线。创建一个交通灯管理器，启动其start方法。

类图设计

Road

属性，name;//表示方向，可以使用Lamp的枚举，vehicles;//车辆的集合

方法，在构造方法中，启动一个线程，每个一段随机时间就向车辆集合中增加一辆车；启动一个定时器，每个1秒，就检查该方向的灯是否为绿，绿就打印车辆集合中的第一辆车通过的信息并remove它。

Lamp

属性，12个方向，定义好其对面方向，灯绿否和下个方向；等的状态，isGreen；相反方向的灯，oppositeLampName；下一个灯，nextLampName；由于要在构造方法中定义一个方向的状态，反方向灯和下一个灯，但是枚举中无法在枚举定义之前引用这个枚举，所以使用字符串表示反方向灯和下一个灯。

方法，toGreen();toRed();，变灯，这两个方法中要让向反方向的灯也随之变化。toRed()方法中还要将下个灯变绿。

LampController

整个系统只有一个管理器，所以这个类设计为单例。在构造方法中需要将第一个灯设置为绿。

方法，start();这个方法中创建一个定时器，每隔10秒将当前灯变红，将下个灯变绿。

MainClass

for循环12条线路，创建一个LampController对象，并调用start()方法。

java实现

/**
     * 路线类
     * @author Administrator
     *
     */
    public class Road {
    
    	private String name;//路线的名字
    	private List<String> vehicles = new ArrayList<String>();//车辆名字
    	/*
    	 * 构造方法中获取路线名字和创建线程判断路灯给车辆放行，创建线程随机增加车辆
    	 */
    	public Road(String name){
    		this.name = name;
    		//创建线程判断路灯，是否放行车辆，也可以同时定时器线程实现
    		Executors.newSingleThreadExecutor().execute(new Runnable() {
    			public void run() {
    				while(true){
    					//获取本线路的路灯
    					boolean isGreen = Lamp.valueOf(Road.this.name).isGreen();
    					//判断路灯
    					if(isGreen){
    						if(vehicles.size() > 0){
    							//车辆通过路口的时间为一秒
    							try {
    								Thread.sleep(1000);
    								System.out.println(Road.this.name + ":" + vehicles.remove(0) + "通过路口");
    							} catch (InterruptedException e) {
    								// TODO Auto-generated catch block
    								e.printStackTrace();
    							}
    						}
    					}
    				}
    			}
    		});
    		//创建线程随机增加车辆
    		Executors.newSingleThreadExecutor().execute(new Runnable() {
    			public void run() {
    				//一共增加100两车上路
    				for(int i = 0; i < 1000; i++){
    					//利用随机数每个1-5秒出现一辆车上路
    					int interval = new Random().nextInt(4) + 1;
    					try {
    						Thread.sleep(interval * 1000);
    						//将车辆放入队列
    						vehicles.add("车辆_" + i);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			}
    		});
    	}
    }

/**
     * 交通灯枚举
     * @author Administrator
     * S2N,S2W,E2W,E2S,
    	N2S,N2E,W2E,W3N,
    	S2E,N2W,W2S,E2N;
     */
    public enum Lamp {
    	//十二个路线
    	S2N("N2S", false, "S2W"),S2W("N2E", false, "E2W"),E2W("W2E", false,"E2S"),E2S("W2N", false, "S2N"),
    	N2S(null, false, null),N2E(null, false, null),W2E(null, false, null),W2N(null, false, null),
    	S2E(null, true, null),N2W(null, true, null),W2S(null, true, null),E2N(null, true, null);
    	private boolean isGreen = false;//是否为绿
    	private String nextLamp;//下一个变色的灯
    	private String oppositeLamp;//对面的灯
    	
    	/*
    	 * 构造方法提供对面灯，颜色，下个灯这个三个属性
    	 * 创建定时器，每隔10秒变灯
    	 */
    	private Lamp(String oppositeLamp, boolean isGreen, String nextLamp){
    		this.nextLamp = nextLamp;
    		this.oppositeLamp = oppositeLamp;
    		this.isGreen = isGreen;
    	}
    	/**
    	 * 获取灯的颜色
    	 */
    	public boolean isGreen(){
    		return this.isGreen;
    	}
    	/**
    	 * 变绿
    	 */
    	public void toGreen(){
    		//本灯变绿
    		this.isGreen = true;
    		//对面灯变绿
    		Lamp.valueOf(this.oppositeLamp).isGreen = true;
    	}
    	/**
    	 * 变红
    	 */
    	public Lamp toRed(){
    		//本灯变红
    		this.isGreen = false;
    		//对面的灯也变红
    		Lamp.valueOf(this.oppositeLamp).isGreen = false;
    		//获取下个灯
    		Lamp next = Lamp.valueOf(this.nextLamp);
    		//下个灯绿
    		if(next != null){
    			next.toGreen();
    		}
    		//返回下个灯
    		return next;
    	}
    }

/**
     * 交通灯管理类
     * @author Administrator
     *
     */
    public class LampManager {
    	//定义一个当前灯的属性
    	Lamp currentLamp = Lamp.S2N;
    	//全局只有一个交通灯，所以这个类设计为单例
    	private LampManager(){}
    	//创建一个懒汉单例
    	private static LampManager lampManager = new LampManager();
    	//获取这个单例
    	public static LampManager getLazyInstance(){
    		return lampManager;
    	}
    	//设计一个定时器，每隔10秒变灯
    	public void start(){
    		//起初，将当前灯变绿
    		currentLamp.toGreen();
    		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
    				new Runnable() {
    					public void run() {
    						currentLamp = currentLamp.toRed();
    						System.out.println(currentLamp + "灯变绿了");
    					}
    				}, 
    				0, 
    				10, 
    				TimeUnit.SECONDS
    			);
    	}
    }

/**
     * 测试方法
     * @author Administrator
     *
     */
    public class MainClass {
    	public static void main(String[] args) {
    		//for12条线路
    		Lamp[] lamps = Lamp.values();
    		for(Lamp lamp:lamps){
    			String name = lamp.name();
    			Road road = new Road(name);
    			System.out.println(name + "开通了");
    		}
    		//创建一个交通灯管理器
    		LampManager lampManager = LampManager.getLazyInstance();
    		//开启对交通灯的管理
    		lampManager.start();
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd6aGlzaGVu_size_16_color_FFFFFF_t_70]: /images/20220422/177d7e62bcd443dd962baf85622aaf60.png