交通灯管理系统
面向对象分析的具体化
交通灯类程序编写
线路类程序编写
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
1. 面向对象的分析具体化
1). 按照需求分析一辆车穿过一条线路的过程
(1). 模拟过程
一辆车必须先产生，然后才能启动运行。车辆主要是在线路上运行。车辆一定要在线路类实例中生成。一辆车被生成之后，就在这个线路实例上运行。一旦看到这条线路上的交通灯是绿色的时候，就可以通过条线路了。如果是红色就没有办法通过这条线路。
(2). 具体分析每一个类
【*】这个交通灯管理系统，就从线路类开始分析
[1]. 线路类分析
{1}. 成员属性聚合关系分析
根据需求分析：车辆一定要生成出来，所以一定是由线路类实例生成的。同时线路类内部要聚合一个交通灯类的实例，这个交通灯实例和这个线路是一一对应的。
【结论】线路类中应该有车辆类实例、交通等类实例
{2}. 属性聚合关系数量关系分析 ----这是很关键的
{2}1. 车辆实例和线路类实例的数量关系(仅考虑这辆车在这条线路上通过就没有了)
1车辆--->1线路 1线路 ---->车辆 ====> 线路：车辆 1对N的关系
所以在线路类的成员变量中应该聚合一个车辆类的集合
{2}2. 交通灯类实例和线路类实例的数量关系
1 交通灯--->1线路 1线路 ---->1交通灯 ====> 线路：车辆 1对1的关系
所以在线路类的成员变量中应该聚合一个交通灯类的对象，而不是集合。
{3}. 成员方法分析
{3}1. 汽车会自动出现，穿过线路对象之后也会自动消失。并且线路类中拥有汽车类的集合数据，因此线路类对外提供了增加车辆和减少车辆的方法。
{3}2. 汽车看到自己所在路线对应的灯绿了就穿过路口吗？不是，还需要看其前面是否有车，看前面是否有车，该问哪个对象呢？该问线路类对象，线路类对象中存储着车辆的集合，显然路上就应该有增加车辆和减少车辆的方法了。
[2].交通灯类分析
{1}. 成员属性聚合关系分析
{1}1. 本来这个交通灯类有一个状态变量表示这个灯的颜色即可，红灯或者绿灯
{1}2. 由于在线路上做了简化，每一条线路都有一条对应的线路并且有切换的轮转次序。因此这种简化使得我们在交通灯类的内部聚合一个对应线路的交通灯类型的对象 +一个下一个切换轮转次序的交通灯类对象。
{2}. 成员属性聚合数量关系分析
这个很简单，一个交通灯和对应线路的交通灯是一对一关系。同时一个交通灯和下一个轮转的交通灯是固定的(同方向的直行先，左拐后)，所以也是一对一的关系
{3}. 成员方法分析
每个交通灯要有变亮和变黑的方法，并且能返回自己的亮黑状态。 ---- 这些方法是对表示交通灯颜色的状态变量的控制的方法
{4}.【左拐+直行 和 右拐线路交通灯的具体处理】
{4}1. 总共有12条路线，因此系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制，但是为了让程序采用统一的处理方式，故假设出有四个右拐弯的灯，只是这些灯为常亮状态，即永远不变黑。
{4}2. 除了右拐弯方向的其他8条路线的灯，它们是两两成对的，可以归为4组，所以，在编程处理时，只要从这4组中各取出一个灯，对这4个灯依次轮流变亮，与这4个灯方向对应的灯则随之一同变化，因此交通灯类中要有一个变量来记住自己相反方向的灯，在一个交通灯类对象的变亮和变黑方法中，将对应方向的灯也变亮和变黑。每个灯变黑时，都伴随着下一个灯的变亮，交通灯类中还用一个变量来记住自己的下一个灯。
[3].车辆类分析
【简化】
这里并不要体现车辆移动的过程，只是捕捉出车辆穿过路口的过程，也就是捕捉路上减少一辆车的过程。 所以，这个车并不需要单独设计成为一个对象，用一个字符串表示就可以了。-----使用了Java内建String类对象来替代自定义的车辆类
[3].交通灯控制器类分析
{1}. 成员属性聚合关系分析
聚合一个表示当前交通灯控制器要控制的交通灯类对象
{2}. 成员属性聚合数量关系分析
一个交通灯控制器类和在一个时刻只能控制一个交通灯。所以聚合关系是一对一。
{3}. 成员方法分析
需求中：红绿灯交换时间间隔自定，可以设置。所以交通灯控制器类中的方法就应该有一个操作这个当前交通灯的方法，切换它的红绿灯状态。之后再切换到其他的红绿灯。
2. 交通灯类Lamp的程序编写
1). 编写过程中注意事项
(1). Lamp类应该采用枚举更好
所有地方的交通灯都是一样的，具有12个代表12条线路的交通灯，不会多也不会少，因此这种固定不变的类Lamp类采用JDK5的枚举来做显然具有很大的方便性
(2). 一对一的映射关系可以使用String类型来替代Lamp成员属性
由于Lamp类中的表示对应线路的属性和下一条切换线路的属性都是一对一的关系，因此一一对一的关系可以采用String类型来简化替代Lamp类聚合的表示对应的Lamp类的实例和表示下一条交通灯的Lamp类实例。
2). Lamp类代码示例
(1).Lamp的点亮和灭掉交通灯的方法
增加让Lamp变亮和变黑的方法：light和blackOut，对于S2N、S2W、E2W、E2N这四个方向上的Lamp对象，这两个方法内部要让相反方向的灯随之变亮和变黑，blackOut方法还要让下一个灯变亮。
(2). Lamp类示例代码
package cn.isoftstone.interview.traffic;
/**
* 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp枚举元素。
* 程序代码只需要控制每组灯中的一个灯即可：----括号中的表示该线路的交通灯对应的线路的交通灯
* S2N(N2S)、S2W(N2E)、 E2W(W2E)、 E2S(W2N) -----受红绿灯控制的交通灯
* S2E(N2W) 和E2N(W2S) -----不受红绿灯控制的交通灯
* @author XinmingZhang
*/
public enum Lamp {
//每个枚举元素各表示一个线路方向上的控制灯
//左转的两条主路+ 两条直行线 ----初始化这些主路的灯光是灭的---Red
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),
//四条右拐的路 常绿 ---四个右转弯方向的灯，因为其不受红绿灯控制，所以可以假设它们总是绿灯
N2W(null, null, true), W2S(null, null, true), S2E(null, null, true), E2N(null, null, true);
//当前灯的状态，是否为绿
private boolean lighted =false;
//当前线路交通灯的对应线路的交通灯
private String opposite =null; //一对一 所以使用String的name替代
//当前线路交通灯的被切换到下一个交通灯
private String next =null; //一对一 所以使用String的name替代
/**
* 构造函数
* @param opposite ----当前线路对应线路的交通灯的名字
* @param next --------当前线路的下一条线路的交通灯的名字
* @param lighted -----这条线路的交通灯初始化的时候被点亮(代表绿灯)
*/
private Lamp(String opposite, String next, boolean lighted){
this.lighted =lighted;
this.opposite =opposite;
this.next =next;
}
/**
* lighted属性的Getter
* @return---获取当前线路的交通灯的状态
*/
public boolean isLighted() {
return lighted;
}
/**
* 点亮该灯----点亮表示将灯变成绿色的
* 某个灯变绿时，它对应方向的灯也要变绿
*/
public void light(){
this.lighted =true;
//同时要点亮对应路段的交通灯
if(this.opposite !=null){
LampoppositeLamp =Lamp.valueOf(opposite);
oppositeLamp.light();
}
System.out.println(name()+" lamp is green, 下面可以看到6个方向看到汽车穿过!");
}
/**
* 灭掉该灯----也就是将该路段的交通灯变红
* @return----返回下一站切换的路灯
*/
public Lamp blackOut(){
//当前灯变红，对应方向的灯也变红
this.lighted =false;
//同时要灭掉对应路段的灯
if(this.opposite !=null){
LampoppositeLamp =Lamp.valueOf(opposite);
oppositeLamp.blackOut();
}
//点亮下一对应的灯
LampnextLamp =null;
if(next !=null){
nextLamp=Lamp.valueOf(next);
nextLamp.light();
System.out.println("绿灯从"+ name()+"--->切换为"+next);
}
return nextLamp;
}
}
3. 线路类Road程序编写
1). 编写过程中注意事项
(1). 删除方法 ------代表车辆穿过这条线路
每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
(2). 增加车辆和删除车辆的方法简化
这两个方法仅仅被使用一次之后即可，不需要被其他的方法调用。因此简化程序，就直接放入到Road类的构造方法即可。
(3). Road类构造方法设计思路
[1]. 先设计成单线程的构造方法
先生成车(初始化成员对象) ----> 在放行这些车写成单线程程序如下：
public Road(Stringname){
this.name =name;
//随机的时间间隔生成1000辆车
for(int i=0; i<1000; i++){
try {
int randomTime =(newRandom().nextInt(10)+ 1)*1000;
Thread.sleep(randomTime);
this.vehichles.add(this.name+"_"+ i);
} catch(InterruptedException e) {
// TODOAuto-generated catch block
e.printStackTrace();
}
}
//每隔一秒放行一辆车
while(vehichles.size()>0){
//1s放行一辆车
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
e.printStackTrace();
}
//观察是否可以通过这条路 ---- 观察这条路上的对应的交通灯对应的状态
boolean lighted =Lamp.valueOf(this.name).isLighted();
if(lighted){
System.out.println(vehichles.remove(0)+" istraversing!");
}
}
}
[2]. 分析这个单线程程序存在的问题
{1}. Road类实例化的时候，如果想生成的车辆的数目非常庞大，那么主线程执行第一个for循环的时间将会非常的漫长，这样就没有办法进行下面的代码了。
{2}. 按照主线程执行的顺序：先生成所有的车辆，再把所有的车辆每隔一秒依次放行。这显然是不合理的。一定是生成车辆的同时，也同时放行相应的车辆。显然这两块应该使用两个线程去执行相应的代码 ---- 多线程
[3]. 单线程程序的多线程化的图示
[4]. 增加车辆代码块的多线程化具体实现步骤
{1}. 传统的线程技术办法就是将这段代码封装到自定义Runnable实现子类的run方法中。然后创建这个Runnable实现子类对象并且传到线程Thread的构造方法中。最后决定要实例化多少个线程实例来执行这段代码并启动这些线程。
{2}. 这里采用线程的新技术来替代传统技术
{2}1. 通过java.util.concurrent.ExecutorService类的静态方法newSingleThreadExecutor产生线程池的方法，创建一个线程池，这个方法产生的线程池中仅仅含有一个线程。 ----- 这里面就使用一个线程去执行多线程任务
{2}2. 通过线程池(ExecutorService类的实例)的execute方法来执行Runnable实现子类实例中run方法的内容。----- execute方法相当于原来的线程实例的start方法
[5].放行车辆代码块的多线程化具体实现步骤
{1}. 这里仍然采用线程的新技术来替代传统技术
{1}1. 使用的类和方法
通过java.util.concurrent.Executor类的静态方法newScheduledThreadPool产生可以按照一个固定的时间来执行Runnable实现类实例的线程池的方法，创建一个可以按照固定时间间隔执行任务的线程池(ScheduledExecutorService接口类型)，这个方法产生的线程池中仅仅含有一个线程。 ----- 这里面就使用一个线程去执行多线程任务
{2}2. 通过可以以固定时间间隔执行任务的线程池(ScheduledExecutorService类的实例)的scheduleAtFixedRate方法来执行Runnable实现子类实例中run方法的内容。 ----- scheduleAtFixedRate方法相当于原来的线程实例的start方法
{2}3. scheduleAtFixedRate方法的原型
public ScheduledFuture<?>scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnitunit);**********
initialDelay：线程启动之后要隔多长时间才能执行第一次任务
period：每两次执行任务的时候，间隔时间是多少
TimeUnit：是中间两个表示时间的参数的单位。
{2}3. 在使用传统线程技术的时候，我们使用Thread.sleep(1000)方法来间隔1s来执行代码。这样对应到scheduleAtFixRate这个方法中的时候，Thread.sleep()方法就可以直接拿掉了，直接将sleep方法之后的代码放到Runnable子类的run方法中。
Thread.sleep(1000)体现在对scheduleAtFixedRate这个方法中最后两个参数的设置上。如图所示：
{3}. Runnable实现子类要不要直接抽取出来形成的单独的类呢？
最好不要。因为要抽取出来的多线程代码中含有对Road类的成员变量name和vehicles这两个变量的访问。如果直接抽取走的话，再想在run方法中访问这些变量的话就会相对麻烦。因此采用局部匿名类对象可以解决的这个问题。
{4}. 增加车辆代码块中也含有Thread.sleep方法，是否也可以写到scheduleAtFixedRate方法中呢？
不可以！因为那个sleep的时间是随机的，不是固定的。scheduleAtFixedRate中的period表示周期的长度，要求是固定的参数。
2). Road类的示例代码
package cn.isoftstone.interview.traffic;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
importjava.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 每个Road对象代表一条路线，总共有12条路线，即系统中总共要产生12个Road实例对象。
* 每条路线上随机增加新的车辆，增加到一个集合中保存。
* 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
* @author XinmingZhang
*
*/
public class Road {
//模拟该条路上的汽车集合
private List<String> vehichles =new ArrayList<String>(); //使用List接口 ---面相接口编程
//线路的线路名称 ----- 实际聚合的是Lamp类实例
private String name; //实际通过这个name获取这条线路一对一的Lamp类对象
/**
* Road类的构造方法
* @param name ----该条线路的线路名称
*/
public Road(String name){
this.name =name;
//启动另一个线程来创建该条路上的车辆 ---模拟车辆不断随机上路的过程，使用线程池，通过产生单个线程的方法，创建一个线程池
ExecutorServicepool =Executors.newSingleThreadExecutor();
pool.execute(new Runnable(){
//通过for循环来模拟车辆的增加 ----随机时间间隔生成一辆车 间隔不固定
@Override
public void run() {
for(int i=0; i< 1000; i++){
try {
//按照一个随机的时间间隔生成车辆
int randomTime =(new Random().nextInt(10)+ 1)*1000;
Thread.sleep(randomTime);
Road.this.vehichles.add(Road.this.name+"_"+ i);
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
//启动另一个线程 来减少当前这条路上的车 以模拟这辆车通过了这条路
ScheduledExecutorServicetimer =Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
if(vehichles.size() >0){
//查看当前路段对应的交通灯是不是已经亮了 亮了的话 让该条路上的车辆通过
boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
if(lighted){
System.out.println(vehichles.remove(0)+" is traversing!");
}
}
}
},
1,
1,
TimeUnit.SECONDS);
}
}
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
