交通灯管理系统项目

最新推荐文章于 2014-08-25 13:15:58 发布

mumianhuakaiyang

最新推荐文章于 2014-08-25 13:15:58 发布

阅读量541

点赞数

文章标签：交通 null string n2 timer random

本文链接：https://blog.csdn.net/mumianhuakaiyang/article/details/6199099

版权

项目分析

路：一共12条路线
先考虑一个方向的线比如：南到北的直线、南到西的拐弯。那么北到南的路线正好相反
东到西这个路线：东到西的直线、东到南德拐弯。反之西到东、西到北正好相反。加上各条路线向右拐弯的路线共12条。但只考虑4条就可以。
路跟灯绑定汽车看自己所在的这条路上的灯是什么颜色判断是否过路口，而且还要判断前面是否有车（怎么问自己前面有没有车问路）路（是个集合）。所以，就应该有汽车有增加和减少

的方法，因为只是捕捉车减少的过程。所以说，车不用时对象用字符串就可以了。

路：
                    //newScheduledThreadPool 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
                    //ExecutorService可安排在给定的延迟后运行或定期执行的命令
                    ExecutorService pool = Executors.newScheduledThreadPool(1);
                    pool.execute(new Runnable(){

                            public void run() {
                                      for(int i=1;i<1000;i++){
                                                try {
                                                         //用一个随机数来控制因为不知道什么时候路上增加一辆车
                                                        Thread.sleep((new Random().nextInt(10)+1) * 1000);
                                               } catch (InterruptedException e) {
                                                        e.printStackTrace();
                                               }
                                               //内部类访问外部类的变量用法
                                                list.add(Road.this.name + "_" +i);
                                      }
                            }
                    });
                   //定时器第一个参数new Runnable（）是个接口加上大括号表示实现这个接口的类要重写run这个方法，第二个参数是表示什么时间开始，第三个参数表示多久再次执行

，第四个参数表示用什么时间单位
                    ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
                   timer.scheduleAtFixedRate(
                                     new Runnable(){

                                               public void run() {
                                                        if(list.size()>0){
                                                                 boolean lighted =
                                                                           lamp.valueOf(Road.this.name).isLighted();
                                                                 if(lighted){
                                                                           System.out.println(list.remove(0)+"过马路了");
                                                                 }
                                                        }
                                               }

                                     },
                                     1,
                                     1,
                                     TimeUnit.SECONDS);

          }

灯：12个灯（包括路线右拐的灯）可以用枚举。考虑灯亮的顺序他对应的灯和他下一个灯。
所以只设计4个灯比如说：南到北的路线，南到北直线的灯然后是南到西的灯在执行时把他对象的路线一起执行，然后再考虑东到西的路线用上，所以只考虑4个灯。
灯里有三个属性:自己的状态、对应的灯、下一个灯

灯：
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 lamp(String opposite,String next,boolean lighted){
                   this.opposite = opposite;
                   this.next = next;
                   this.lighted = lighted;
         }

         private lamp(){

         }
         private boolean lighted; //灯的状态

private String opposite;//对应的灯

         private String next; //下一个灯
        //获得灯的状态
         public boolean isLighted(){
                   return lighted;
         }
         //把灯变绿
         public void light(){
                   this.lighted = true;
                   if(opposite != null ){
                            lamp.valueOf(opposite).light();
                   }
                   System.out.println(name()+"lamp is green 下面总共应该有6个方向能看到汽车");
         }
         //把灯变红
         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);
                            lamp.valueOf(next).light();

                   }
                   return nextLamp;
         }

灯控制器：进行灯的红绿切换。控制4组灯的切换
有个变量：当前绿的灯是哪一个有个定时器，时间一到把当前等变红当这个变红的同时返回下一个绿灯

灯控制器：
private lamp dangQianDeng;

         public lampKongZhi(){
                   dangQianDeng = lamp.S2N;
                   dangQianDeng.light();

                   //定时器
                   ScheduledExecutorService time = Executors.newScheduledThreadPool(1);
                   time.scheduleWithFixedDelay(
                                     new Runnable(){
                                               //这个方法很有意思！把灯变成红的同时返回下一个绿灯
                                               public void run() {
                                                        dangQianDeng = dangQianDeng.blackOut();
                                               }

                                     },
                                     10,
                                     10,
                                     TimeUnit.SECONDS);
         }

项目总结

线程的运用
/*ExecutorService这个接口可安排在给定的延迟后运行或定期执行的命令
Executors这个类调用newScheduledThreadPool这个方法创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行*/
ExecutorService pool = Executors.newScheduledThreadPool(1);

定时器第一个参数线程对象，第二个参数是表示什么时间开始，第三个参数表示多久再次执行，第四个参数表示时间单位
ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);

枚举---valueOf()可以把你给他的相应字符串返回一个其对应的枚举对象
lamp.valueOf(opposite).light();

内部类访问外部类的变量用法外部类名.this.变量名
list.add(Road.this.name + "_" +i);