黑马程序员_Java_交通灯系统

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！----------------------

交通灯管理系统:

结合现实十字路口分析:

                   由图可知,总共有12条路线,假设每条路线都由一个红绿灯对其控制,
                                 现实中,右转弯是随时可以转,不用看红绿灯的,所以我们把右转灯一直设为
                                 绿灯,保证随时都可以通行.

                  其他8条路线都是两两成对的,那么可以归为4组路线.图中用同一颜色标记的既是一对,
                               只需要用同一个红绿灯控制即可,另外一点很重要,要控制好4组路线对应的灯之间的
                              切换以及时间.

面向对象分析:
  
                     a.每条路上都会随机产生多辆车,路线上要随机增加新的车,在灯绿期间,该路线上的车开走.
                     应该定义一个Road类,至于路上的车,我们不需要用到车这个对象,所以我们完全可以用
                     字符串来充当不同的车.车停在路上,所以在Road类里面还要定义一个集合,用来储存这些
                     代表车的字符串.
  
                    b.由于有12条线路,每个灯对应一条线路,所以应该有12个灯,
                    当本线路灯亮着的时候,两两对应的另外一条线路的灯应该也是亮着的!
                    当本线路灯黑了,下一个路线的灯就应该变亮.
   
                   c.对红绿灯的控制,控制灯在多少时间后变绿,多少时间后变红,然后下一个灯变绿.依次循环下去.

代码体现:
                   import java.util.List;
                   import java.util.ArrayList;
                   import java.util.concurrent.Executors;
                   import java.util.concurrent.ScheduledExecutorService;
                   import java.util.concurrent.TimeUnit;

                  //Road类
                  class Road
                  {
                           //创建一个数组集合,用来装路上的车,把车视为字符字符串.
                           private List<String> car=new ArrayList<String>();
                           //路名
                           private String name;
                           //带参数(路名)的构造函数
                           public Road(String name)
                           {
                                   this.name=name;
                            //用线程池来形容路上的车,让路上的车随便哪辆先走
                            ExecutorService pool = Executors.newSingleThreadExecutor();
                            //匿名内部类,放入线程池,随便线程池里的哪条线程执行.
                             pool.execute(new Runnable(){
                             public void run()
                            {
                                     //产生1000辆车
                                      for(int i=1;i<1001;i++)
                                      {
                                          try {
                                                  //1到10秒内随机产生车辆
                                                  Thread.sleep((new Random().nextInt(10)+1)*1000);
                                                   } catch (InterruptedException e) {
                                                                   e.printStackTrace();
                                                   }
                               //车子进入这条路
                                car.add(Road.this.name+""+i);
     
                                           }
    
                                 }
                         });

                           //定义一个定时器,如果灯是亮的,第一辆车就开走!
                           ScheduledExecutorService timer= Executors.newScheduledThreadPool(1);
                           timer.scheduleAtFixedRate(
                           new Runnable(){
                           public void run()
                           {
                                      if(car.size()>0)
                           {
                            boolean light=Lamp.valueOf(Road.this.name).isLighted();
                                          if(light)
                                         {
                                                   System.out.println(car.remove(0)+"已经开走!");
                                          }
                                   }
      
                              }
                                      },1,1, TimeUnit.SECONDS);//以秒为单位.
                          }
                   }

                     //定义一个Lamp枚举类.
                      enum Lamp
                      { 
                                  //N:北 ,S:南,W:西,东:E ,2:to的意思.
                            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 boolean lighted;
                             //与此线路对应线路
                             private String opposite;
                             //下一个灯
                             private String next;
                              private Lamp(){}
                             //带三个参数的构造
                             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;
                                      //把对应线路灯变绿
                                       if(opposite!=null)
                                       {
                                                  Lamp.valueOf(opposite).light();
                                        }
                              }
                           /*把此线路以及对应线路的灯变红,
                           并且把下一个线路的灯变绿,且返回下一个灯.*/
                            public Lamp blackOut()
                           {
                                         //把灯变红
                                        this.lighted=false;
                                        //把对应线路灯变红
                                        if(opposite!=null)
                                         {
                                                  Lamp.valueOf(opposite).blackOut();
                                          }
                            //把下一个路线的灯变绿.
                          Lamp nextLamp=Lamp.valueOf(next);
                                      if(next!=null)
                                     {
                                               nextLamp.light();
                                     }
                                         return nextLamp;
                                  }
                           }

                       //红绿灯控制
                       import java.util.concurrent.Executors;
                       import java.util.concurrent.ScheduledExecutorService;
                       import java.util.concurrent.TimeUnit;
                       class LampController
                       {
                               //当前灯
                               private Lamp currentLamp;
                               public LampController()
                           {
                                  //当前灯为S2N的灯
                                  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);
                                 }
                          }

                    //测试类.
                    public class TrafficTest
                    {
                              public static void main(String[] args)
                     {
                               //把12条路线的名字封装进数组.
                               String[] wayName={
                               "S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};
                      //遍历
                      for(String s :wayName)
                      {
                             //创建路线对象.
                              new Road(s);
                       }
                       //创建交通灯控制对象.
                        new LampController();
                      }
                 }

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！----------------------