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

最新推荐文章于 2015-05-10 00:19:28 发布

yueyushanhe

最新推荐文章于 2015-05-10 00:19:28 发布

阅读量551

点赞数

分类专栏： java项目实践

本文链接：https://blog.csdn.net/yueyushanhe/article/details/8763925

版权

java项目实践专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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

交通灯管理系统

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

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

例如：

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

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

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

。。。

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

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

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

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

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

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

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

图解：

分析：

1.车辆穿过的方向总共有12个，相当于有12条路线。路线上在随机时间内增加车辆，并且在绿灯期间每秒钟放行一辆车。

2.每条路线对应一个信号灯，总共有且只有12个灯。信号灯有两种状态，分别是绿灯和红灯。信号灯有变绿和变红以及判断当前状态3个方法。

3.信号灯控制器是用来以固定频率切换信号灯的状态，从而操作整个系统运转。

思路：

1.需要创建3中对象，分别是Road对象，Lamp对象以及LampController对象。

2.Road对象共有12个，对象中自有一个集合，在对象产生后，用来在随机时间内增加车辆到集合中以及每隔1秒判断当前方向的信号灯是否为绿灯，如果是则移除集合中第一位的车辆。

3.Lamp对象是固定的，因此可以设置成枚举类，枚举的常量为12个，对应12个方向的路线。但主要考虑S2N,S2W,E2W,E2S四个方向上灯的变化。因为其对应的相反四个方向的灯的变红是相同的，另外4个方向都是右转方向，直接当做常绿考虑即可。灯的变绿方法中，当前灯变绿，同时使相反方向的灯也变绿。同样，变红方法中，当前和相反方向的灯都变红，并且让当前灯的下一个灯变绿。

4.LampController对象中主要操作一个定时器来以固定频率(每隔10秒)操作当前信号灯的红绿切换，使当前灯变红，下一个灯变绿，使整个系统运转起来。

5.MainClass类创建12个Road对象，然后获得LampController对象，使程序启动。

代码：

Road类：

package com.itheima;

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个方向。
 * Road对象就如同一个容器，存储着车辆元素，随机增加车辆可以看作是往容器中存储元素。
 * 而车辆通过则可以看作是容器remove元素。
 */
public class Road {
	/*内部定义一个集合容器，存储车辆*/
	private List<String> vehicles = new ArrayList<String>();
	
	private String name;
	public Road(String name){
		this.name = name;
		/*创建一个线程，用来随机生成车辆*/
		ExecutorService pool = Executors.newSingleThreadExecutor();
		pool.execute(new Runnable(){
			public void run(){
				for(int i=1;i<100;i++){//每个方向总共生成99辆车
					try {
						/*在1-10秒内随机生成一辆车*/
						Thread.sleep((new Random().nextInt(10)+1)*1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					/*以路的方向+编号来定义一辆车*/
					vehicles.add(Road.this.name+"-"+i);
				}
			}
		});
		/*创建一个定时器，每隔一秒，只要Road对象对应方向的灯是绿灯，车辆就通过一辆*/
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						/*判断该Road对象对应方向的灯是否为绿灯*/
						boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
						if(lighted){
							if(vehicles.size()>0)//确定容器内有元素，然后移除最前面的元素，即车辆通过
								System.out.println(vehicles.remove(0)+" is passing through!");
						}
					}
				},
				1,
				1,
				TimeUnit.SECONDS
				);
	}
	
}

Lamp类：

package com.itheima;

/**
 * Lamp对象代表每个方向上的灯，总共有12个方向。因为灯从一开始就有且只有12个。故用枚举类描述。
 * 12个灯中有4个右转的灯没有限制，可以考虑是常绿的。另外8个灯中都是一一对应的，因此只考虑4个灯，其余4个灯的与之都是对应的。
 * 这个4个灯分别为S2N,S2W,E2W,E2S,对应的4个灯为N2S,N2E,W2E,W2N.常绿的灯为S2E,E2N,N2W,W2S.
 * 灯的属性分别有是否为绿灯，对应的相反的灯，以及下一个灯。
 */
public enum Lamp {
	/*主要操作的四个灯，对应的属性分别是 相反的灯、下一个灯、以及初始为红灯*/
	S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
	/*主要的灯对应的四个灯，相反的灯和下一个灯都是null，初始为红灯*/
	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 boolean lighted;
	/*相反和下一个灯的属性定义成String类，可以通过枚举的valueOf方法获取其对应的灯对象*/
	/*不能定义成Lamp类，因为初始化时会出现相反和下一个灯尚未定义的问题*/
	private String opposite;
	private String next;
	/*枚举的构造函数必须是私有的*/
	private Lamp(String opposite,String next,boolean lighted){
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}
	public boolean isLighted(){//判断是否为绿灯
		return lighted;
	}
	/*使灯变绿*/
	public void light(){
		this.lighted = true;
		System.out.println(name()+"  is green! 下面总共会有六个方向会有车辆通过！");
		if(opposite!=null)//如果相反方向的灯不为空，也使其变绿
			Lamp.valueOf(opposite).light();
	}
	/*使灯变红*/
	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;//变红的函数返回值类型为Lamp类，返回下一个灯，方便控制器操作
	}
}

LampController类：

package com.itheima;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * 控制器主要用来控制灯的变化，从绿到红的变化。
 * 因为灯的跳转是固定频率的，所以用定时器，，每隔10秒跳转一次。
 * 直接在构造函数里描述，对象已建立，就会自动运行。
 */
public class LampController {
	/*定义一个当前灯，通过当前灯的变化来运转整个系统*/
	private Lamp currentLamp;
	
	LampController(){
		/*初始化默认当前灯是 S2N,且为绿灯*/
		this.currentLamp = Lamp.S2N;
		currentLamp.light();
		
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						/*每隔10秒当前灯变红 ，下一个灯变绿。通过blackOut方法返回下一个灯，并赋给当前灯。*/
						currentLamp  = currentLamp.blackOut();
					}
				},
				10,
				10,
				TimeUnit.SECONDS
				);
	}
}

MainClass：

package com.itheima;


public class MainClass {

	/**
	 * 主函数，生成对象，启动系统。
	 */
	public static void main(String[] args) {
		/*首先生成12个方向上路的对象*/
		String[] roadDirections = new String[]{
				"S2N","S2W","E2W","E2S",
				"N2S","N2E","W2E","W2N",
				"S2E","E2N","N2W","W2S"
		};
		for(int i=0;i<roadDirections.length;i++){
			new Road(roadDirections[i]);
		}
		/*生成控制器对象，启动系统*/
		new LampController();
	}

}

总结：

1.在一个系统中，需要运用面向对象的思想分析每个对象以及各个方法的所属关系。通过明确所需对象以及其方法，完善整个设计思路。在交通灯项目中，

分析的对象应该有路，车辆，信号灯，控制器，但因为不考虑车辆的具体行为，因此可以把路设置成一个容器，而车辆作为其中的元素来存储和移除。这样

系统需要操作的对象就只有3个。明确对象和具体行为时，更加要理清对象与对象之间的关系。因为面向对象的思想就是在产生对象，使用对象和维护对象。

2.虽然整个项目中思想更为重要，但在代码的书写时，需要对每个部分准确的书写，要注重细节。往往一个小的问题，可以让后期的调试非常困难。

特别在Lamp类的描述中，对于信号灯的方法描述时尤其需要注意，变绿和变红时，相反的灯也要变化，且变红时，要使下一个灯变绿，这样才能维持整个

系统的运转。另外在12个方法的书写时，也要格外小心，一个字母的错误，可能导致运行时没有异常，但信号灯切换数次后就不切换的现象。

3.对于定时器的应用，以后在项目中应该也是非常常用。对于固定频率产生的行为，要记得使用定时器。另外产生线程的新方法较传统的方法更加灵活，可以多加使用。