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

最新推荐文章于 2020-07-13 09:40:14 发布

程洋

最新推荐文章于 2020-07-13 09:40:14 发布

阅读量2.1k

点赞数 1

本文链接：https://blog.csdn.net/u012974712/article/details/25188227

版权

题目:交通灯管理系统

需求:

1)异步随机生成各个路线上的车辆.

例如:

(1)由南向北行驶的车辆 ----直行车辆

(2) 由西向南行驶的车辆 ----右转车辆

(3)由东向南行驶的车辆 ----左转车辆

…

2)信号灯颜色选择范围

忽略黄灯，只考虑红灯和绿灯

3)左转车辆和右转车辆的要求

(1) 左转车辆受到控制信号灯的控制

(2) 但是右转车辆不受信号灯控制

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

4) 其他说明

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

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

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

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

十字路口简化图及注释

1)简化图

2) 注释

(1) 图中字母数字含义

N--北 S--南 W--西 E--东 2--to S2N--由南向北

(2)图中共12条路线,按其运行方式可分四种

直行(4条): S2N N2S W2E E2W

左拐(4条): S2W W2N N2E E2S

右拐(4条): S2E E2N N2W W2S

(3)路线简化

直线和左拐的必须遵守交通规则可看成4对,设计时只用考虑其中四条

右拐的可视为常绿.

(4)车辆通行按照先直行,后左转

S2N---S2W---E2W---E2S--循环

面向对象初步分析及各个模块

1)对题目分析得出所需类

交通灯(Lamp)

路(Road)

车(Car),本系统中不考虑车的运行状况,可以将车作为路上的数据,没有必要作为类

交通灯控制器(LampController)

主函数

public class MainClass {  
      public static void main(String[] args) {    
             
          //给出所有的方向   
            String[]directions =new String[]{  
                        "S2N", "S2W", "E2W", "E2S",  
                        "N2S", "N2E", "W2E", "W2N",  
                        "N2W", "W2S", "S2E", "E2N"  
            }; 
          //实例化Road的过程    
            for(int i=0; i< directions.length; i++){  
                  new Road(directions[i]);  
            } 
	 //实例化交通灯控制器实例     
            new LampController();
      }  
}

路(Road)部分

package cn.itcast.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 {    
     private List<String> vehichles =new ArrayList<String>();    //使用List接口 ---面相接口编程   
      private String name;    //实际通过这个name获取这条线路一对一的Lamp类对象   
      public Road(String name){  
            this.name =name;  
             
            //启动另一个线程来创建该条路上的车辆,模拟车辆不断随机上路的过程，使用线程池，通过产生单个线程的方法，创建一个线程池   
              ExecutorService pool =Executors.newSingleThreadExecutor();  
            pool.execute(new Runnable(){  
               //通过for循环来模拟车辆的增加随机时间间隔生成一辆车  间隔不固定     
                  public void run() {   
                        for(int i=0; i< 1000; i++){  
                              try {  
                                    //按照一个随机的时间间隔生成车辆    
                                          Thread.sleep((new Random().nextInt(10)+ 1)*1000;); 
                                    vehichles.add(Road.this.name+"_"+ i);  
                                  }
			   catch (InterruptedException e) {    
                                    e.printStackTrace();  
                              }  
                        }  
                  }  
            });  
             
            //启动另一个线程 来减少当前这条路上的车 以模拟这辆车通过了这条路   
              ScheduledExecutorService timer =Executors.newScheduledThreadPool(1);  
            timer.scheduleAtFixedRate(  
                        new Runnable(){  
                              public void run() {     
                                    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);  
      }  
}

交通灯(Lamp)部分

package cn.itcast.traffic;   
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),  
      //四条右拐的路 常绿  
      N2W(null, null, true), W2S(null, null, true), S2E(null, null, true), E2N(null, null, true);   
     private boolean lighted =false; //当前灯的状态               
      private String opposite =null;//当前线路交通灯的对应线路的交通灯 
      private String next =null; //当前线路交通灯的被切换到下一个交通灯   
      private Lamp(String opposite, String next, boolean lighted){  
            this.opposite =opposite;  
            this.next =next;  
      }  
      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个方向看到汽车穿过!");  
      } 
      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;  
      }  
}

交通灯控制(LampController)部分

package cn.itcast.traffic;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;   

public class LampController {  
     private Lamp currentLamp;   
     private LampController(){  
          //指定第一盏亮的交通灯   
            currentLamp =Lamp.S2N;  
          currentLamp.light();  
          //设置定时器   
            ScheduledExecutorServicetimer =Executors.newScheduledThreadPool(1);  
          timer.scheduleAtFixedRate(  
                        new Runnable(){  
                              public void run() {  
                                    //每隔10s切换下一盏亮的交通灯   
                                          currentLamp =currentLamp.blackOut();  
                              }  
                        },  
                        10,  
                        10,  
                        TimeUnit.SECONDS);  
      }  
}