精华内容
下载资源
问答
  •  具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同,不考虑特殊情况下的控制逻辑。  注:南北向车辆与东西向车辆交替放行,同方向等待车辆应先放行直行车辆而后放行左转车辆。  每辆车通过路口...

    ---------------------- 黑马程序员 Android培训、期待与您交流! ---------------------


    package cn.itcast_Trafficlamp;


    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;
     /* 交通灯管理系统
      模拟实现十字路口的交通灯管理系统逻辑,具体需求如下:
      异步随机生成按照各个路线行驶的车辆。
      例如:
      由南向而来去往北向的车辆 ---- 直行车辆

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

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

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

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

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

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

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

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

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

      视频 1—6为分析

      视频7—11为代码设计

      路的分析:增加车辆和减少车辆的方法,做线程使用JDK1.5的新技术:线程池   

      定时器的使用,集合中泛型的使用;

      灯的分析:用到枚举技术

      灯控制器:控制灯的变化情况

      里面需要注意的几个重点:

      1、             注意面向对象的设计

      a)        两块石头磨成石刀,石刀砍树、树做成椅子……

      (Knife KnifeFactory(Stone first,Stone second))

      2、            Lamp枚举类的设计------传入oppsite、next、lighted的设计

      3、             灯亮和熄灭的设计

      重点代码实现:

      路的设计:*/


        public class Trafficlamp {

            List<String> vehicles=new ArrayList<String>();

        private String name=null;

        public Trafficlamp(String name){

            this.name=name;

        ExecutorService pool= Executors.newSingleThreadExecutor();

            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();

                }

                vehicles.add(Road.this.name+"_"+i);  

            }     
      }

    });    

            ScheduledExecutorService timer=Executors.newScheduledThreadPool(1);

                timer.scheduleAtFixedRate(

                        new Runnable(){

        public void run(){

            if(vehicles.size()>0){

        Boolean lighted=Lamp.valueOf(Road.this.name)((Object) Lamp.valueOf(Road.this.name)).isLighted();

            if(lighted){

                System.out.println(vehicles.remove(0)+"   is travelling!");

                }

            }

        }

    },

        1,
        1,

    TimeUnit.SECONDS);

        }

    }
    //灯的设计:

    package cn.ticast.Trafficlamp;

    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),

        S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);

        private String oppsite;

        private String next;

        private boolean lighted;

        private Lamp(String oppsite,String next,boolean lighted){

            this.oppsite=oppsite;

            this.next=next;    

            this.lighted=lighted;
        }
        public boolean isLighted(){

            returnlighted;
        }
            
        public void light(){

            this.lighted=true;

            if(oppsite!=null){

                Lamp.valueOf(oppsite).lighted=true;

            }

            System.out.println(this.name()+"lamp is green,下面会有6个方向能够看到车");
    }

    public void blackOut(){

        this.lighted=false;

        if(oppsite!=null){

            Lamp.valueOf(oppsite).lighted=false;

        }

        Lamp nextLamp=null;

        if(next!=null){

            nextLamp=Lamp.valueOf(next);

            System.out.println("绿灯从"+name()+"-->切换为"+next);

                    nextLamp.light();
                }
            }
      }

      //灯控制器的设计:

    package com.isoftstone.interview;

    import java.util.concurrent.Executors;

    import java.util.concurrent.ScheduledExecutorService;

    import java.util.concurrent.TimeUnit;

        public class LampController {

            public Lamp currentLamp;

            public LampController(){

                currentLamp=Lamp.S2N;

                currentLamp.light();

                ScheduledExecutorService pool=Executors.newScheduledThreadPool(1);

                pool.scheduleAtFixedRate(

                        new Runnable(){

                            publicvoid run(){

                                currentLamp.blackOut();
                            }

                        },

                10,

                10,

                TimeUnit.SECONDS);
            }
    }

      //主类的设计:

    package cn.itcast_HomeWork;

    public class MainClass {

    public staticvoid main(String[] args){

    String[] directions=new String[]{

    "S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"     

          };

          for(int i=0;i<directions.length;i++){

          new Road(directions[i]);
             }
          new LampController();
          }
        }
    }


    ---------------------- 黑马程序员 Android培训、期待与您交流! ---------------------

    展开全文
  • Java编程知识总结—交通灯分析。 交通灯管理系统需求分析: 交通灯管理系统的项目需求  异步随机生成按照各个路线行驶的车辆。 例如:   由南向而来去往北向的车辆 ---- 直行车辆   由西向而来去往南...
    ------- android培训java培训、期待与您交流! ----------
    

    
    

    Java编程知识总结—交通灯分析


    交通灯管理系统需求分析:


    交通灯管理系统的项目需求


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


    例如:


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


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


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


          。。。


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


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


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


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


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


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


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


     


    面向对象的分析与设计


     


    1、每条路线上都会出现多辆车,路线上要随机增加新的车,在灯绿期间还要每秒钟减少一辆车。


    设计一个Road类来表示路线,每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12Road实例对象。


    每条路线上随机增加新的车辆,增加到一个集合中保存。


    每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。


    每条路线每隔一秒都会检查控制本路线的灯是否为绿,一个灯由绿变红时,应该将下一个方向的灯变绿。


    2、设计一个Lamp类来表示一个交通灯,每个交通灯都维护一个状态:亮(绿)或不亮(红),每个交通灯要有变亮和变黑的方法,并且能返回自己的亮黑状态。


    总共有12条路线,所以,系统中总共要产生12个交通灯。右拐弯的路线本来不受灯的控制,但是为了让程序采用统一的处理方式,故假设出有四个右拐弯的灯,只是这些灯为常亮状态,即永远不变黑。


    3、除了右拐弯方向的其他8条路线的灯,它们是两两成对的,可以归为4组,所以,在编程处理时,只要从这4组中各取出一个灯,对这4个灯依次轮询变亮,与这4个灯方向对应的灯则随之一同变化,因此Lamp类中要有一个变量来记住自己相反方向的灯,在一个Lamp对象的变亮和变黑方法中,将对应方向的灯也变亮和变黑。每个灯变黑时,都伴随者下一个灯的变亮,Lamp类中还用一个变量来记住自己的下一个灯。


    4、无论在程序的什么地方去获得某个方向的灯时,每次获得的都是同一个实例对象,所以Lamp类改用枚举来做显然具有很大的方便性,永远都只有代表12个方向的灯的实例对象。


    设计一个LampController类,它定时让当前的绿灯变红。



    Road


    每个Road对象都有一个name成员变量来代表方向,有一个vehicles成员变量来代表方向上的车辆集合。


    Road对象的构造方法中启动一个线程每隔一个随机的时间向vehicles集合中增加一辆车(用一个路线名_id”形式的字符串进行表示)。


    Road对象的构造方法中启动一个定时器,每隔一秒检查该方向上的灯是否为绿,是则打印车辆集合和将集合中的第一辆车移除掉


    importjava.util.ArrayList; 


    import java.util.List; 


    importjava.util.Random; 


    importjava.util.concurrent.ExecutorService; 


    importjava.util.concurrent.Executors; 


    importjava.util.concurrent.ScheduledExecutorService; 


    importjava.util.concurrent.TimeUnit; 


     


    /** 


     *每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12Road实例对象。 


     *每条路线上随机增加新的车辆,增加到一个集合中保存。 


     *每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。 


     * @author张孝祥 www.it315.org 


     * 


     */ 


    public class Road { 


       private List<String> vechicles = newArrayList<String>(); 


         


       private String name =null; 


    /*在这个构造函数中,传回哪个方向的车, 


    先开启一个线程池用于产生车辆,一个定时器用于观察交通灯状态*/ 


       public Road(String name){ 


           this.name = name; 


             


           //模拟车辆不断随机上路的过程  


          //使用线程池,通过产生单个线程的方法,创建一个线程池   


           ExecutorService pool =Executors.newSingleThreadExecutor(); 


      // 


           pool.execute(new Runnable(){ 


               public void run(){ 


                   for(inti=1;i<1000;i++){ 


                       try { 


                           Thread.sleep((newRandom().nextInt(10) + 1) * 1000); 


                       } catch(InterruptedException e) { 


                           e.printStackTrace(); 


                       } 


                       vechicles.add(Road.this.name+ "_" + i); 


                   }                


               } 


                 


           }); 


             


           //每隔一秒检查对应的灯是否为绿,是则放行一辆车     


       //产生一个单线程,创建定时器   


           ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1); 


           timer.scheduleAtFixedRate( 


                   new Runnable(){ 


                       public void run(){ 


       //判断路上是否有车,有则进行相应的操作 


                           if(vechicles.size()>0){ 


                               boolean lighted =Lamp.valueOf(Road.this.name).isLighted(); 


     //每隔1秒让车通行,通行前要先判断灯是否亮,亮了才能通行,即从集合中移除   


                               if(lighted){ 


                                   System.out.println(vechicles.remove(0)+ " is traversing !"); 


                               } 


                           } 


                             


                       } 


                   }, 


                   1, 


                   1, 


                   TimeUnit.SECONDS); 


             


       } 


    } 


    Lamp


     


    系统中有12个方向上的灯,在程序的其他地方要根据灯的名称就可以获得对应的灯的实例对象,综合这些因素,将Lamp类用java5中的枚举形式定义更为简单。


    1、每个Lamp对象中的亮黑状态用lighted变量表示,选用S2NS2WE2WE2N这四个方向上的Lamp对象依次轮询变亮,Lamp对象中还要有一个oppositeLampName变量来表示它们相反方向的灯,再用一个nextLampName变量来表示此灯变亮后的下一个变亮的灯。这三个变量用构造方法的形式进行赋值,因为枚举元素必须在定义之后引用,所以无法再构造方法中彼此相互引用,所以,相反方向和下一个方向的灯用字符串形式表示。


    2、增加让Lamp变亮和变黑的方法:lightblackOut,对于S2NS2WE2WE2N这四个方向上的Lamp对象,这两个方法内部要让相反方向的灯随之变亮和变黑,blackOut方法还要让下一个灯变亮。


    3、除了S2NS2WE2WE2N这四个方向上的Lamp对象之外,其他方向上的Lamp对象的nextLampNameoppositeLampName属性设置为null即可,并且S2NS2WE2WE2N这四个方向上的Lamp对象的nextLampNameoppositeLampName属性必须设置为null,以便防止lightblackOut进入死循环。


     


    代码:


    /** 


     *每个Lamp元素代表一个方向上的灯,总共有12个方向,所有总共有12Lamp元素。 


     *有如下一些方向上的灯,每两个形成一组,一组灯同时变绿或变红,所以, 


     *程序代码只需要控制每组灯中的一个灯即可: 


     * s2n,n2s     


     * s2w,n2e 


     * e2w,w2e 


     * e2s,w2n 


     * s2e,n2w 


     * e2n,w2s 


     *上面最后两行的灯是虚拟的,由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制, 


     *所以,可以假想它们总是绿灯。 


     * @author张孝祥 www.it315.org 


     * 


     */ 


    /**/ 


     


    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), 


       /*由南向东和由西向北等右拐弯的灯不受红绿灯的控制,所以,可以假想它们总是绿灯*/ 


       S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true); 


         


       private Lamp(String opposite,Stringnext,boolean lighted){ 


           this.opposite = opposite; 


           this.next = next; 


           this.lighted = lighted; 


       } 


     


     


       /*当前灯是否为绿*/  


       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() + " lampis green,下面总共应该有6个方向能看到汽车穿过!"); 


             


       } 


         


       /** 


        * 某个灯变红时,对应方向的灯也要变红,并且下一个方向的灯要变绿 


        * @return 下一个要变绿的灯 


        */  


       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; 


       } 


    } 


    LampController


     


    importjava.util.concurrent.Executors; 


    importjava.util.concurrent.ScheduledExecutorService; 


    importjava.util.concurrent.TimeUnit; 


     


    public class LampController{ 


       private Lamp currentLamp; 


         


       public LampController(){ 


           //刚开始让由南向北的灯变绿;      


           currentLamp = Lamp.S2N; 


           currentLamp.light(); 


             


           /*每隔10秒将当前绿灯变为红灯,并让下一个方向的灯变绿*/       


           ScheduledExecutorService timer = Executors.newScheduledThreadPool(1); 


           timer.scheduleAtFixedRate( 


                   new Runnable(){ 


                       public  void run(){ 


                           System.out.println("来啊"); 


                           currentLamp =currentLamp.blackOut(); 


                   } 


                   }, 


                   10, 


                   10, 


                   TimeUnit.SECONDS); 


       } 


     


     


     


    MainClass


     


    1、用for循环创建出代表12条路线的对象。


    2、接着再获得LampController对象并调用其start方法。


     


    public class MainClass{ 


     


       /** 


        * @param args 


        */ 


       public static void main(String[] args){ 


             


           /*产生12个方向的路线*/       


           String [] directions = newString[]{ 


                   "S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"      


           }; 


           for(inti=0;i<directions.length;i++){ 


               new Road(directions[i]); 


           } 


             


           /*产生整个交通灯系统*/        


           new LampController(); 


       } 


     


    } 


     


     


    打印结果:/*N2S lamp isgreen-----有六个方向的车经过 


    S2N lamp is green-----有六个方向的车经过 


    N2S_1 is traversing ! 


    S2N_1 is traversing ! 


    N2W_1 is traversing ! 


    S2N_2 is traversing ! 


    E2N_1 is traversing ! 


    S2E_1 is traversing ! 


    S2N_3 is traversing ! 


    N2S_2 is traversing ! 


    S2N_4 is traversing ! 


    开始跑吧 


    绿灯从S2N-------->切换为S2W 


    N2E lamp is green-----有六个方向的车经过 


    S2W lamp is green-----有六个方向的车经过 


    W2S_1 is traversing ! 


    S2E_2 is traversing ! 


    N2W_2 is traversing ! 


    S2W_1 is traversing ! 


    W2S_2 is traversing ! 


    N2E_1 is traversing ! 


    N2E_2 is traversing ! 


    N2E_3 is traversing ! 


    S2W_2 is traversing ! 


    W2S_3 is traversing ! 


    E2N_2 is traversing ! 


    S2E_3 is traversing ! 


    E2N_3 is traversing ! 


    S2E_4 is traversing ! 


    开始跑吧 


    绿灯从S2W-------->切换为E2W 


    W2E lamp is green-----有六个方向的车经过 


    E2W lamp is green-----有六个方向的车经过 


    E2W_1 is traversing ! 


    N2W_3 is traversing ! 


    E2W_2 is traversing ! 


    W2E_1 is traversing ! 


    E2W_3 is traversing ! 


    W2E_2 is traversing ! 


    W2S_4 is traversing ! 


    E2W_4 is traversing ! 


    N2W_4 is traversing ! 


    W2E_3 is traversing ! 


    S2E_5 is traversing ! 


    E2N_4 is traversing ! 


    E2W_5 is traversing ! 


    W2S_5 is traversing ! 


    N2W_5 is traversing ! 


    W2E_4 is traversing ! 


    展开全文
  • class ...*基础知识 : 关于java5的开启新线程的方法 如张老师所说:记得Executors 就好了 ExecutorService pool = Executors.newSingleThreadExecutor(); pool.execute(new Runnable({}); 自己的理
    class  
    {
    	public static void main(String[] args) 
    	{
    /*
    *基础知识 :
    关于java5的开启新线程的方法
    如张老师所说:记得Executors 就好了
    ExecutorService pool = Executors.newSingleThreadExecutor();
    pool.execute(new Runnable({});
    自己的理解: Executors 是一个工具类 调用 newSingleThreadExecutor 
    是返回一个新的单线程但是这个线程是没有被具体定义。
    ExecutorService 是一个接口 查看方法 有一个execute 方法 要求传入Runnable的接口对象
    故复写run方法定义线程 并执行 
    下面的定时器也可以这么理解
    
    
    */
    /*基础知识 :
    设置定时器的相关代码:
    ScheduleExecutorService timer=  Executors.newScheduledThreadPool(1);
    timer.ScheduleAtFixedrate(Runnable target,delay,period,type_of_time)
    delay: 第一次执行前的延迟;
    period : 每次执行间隔
    tupe_of_time : 前两种时间的类型 具体的为TimeUnit.操作。
    */
    		//每隔一秒检查对应的灯是否为绿,是则放行一辆车		
    		ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
    		timer.scheduleAtFixedRate(
    				new Runnable(){
    					public void run(){
    						if(vechicles.size()>0){
    							 lighted = true;//先暂时设置为true,应该是判断当前灯的状态。
    							if(lighted){
    								System.out.println(vechicles.remove(0) + " is traversing !");
    							}
    						}
    						
    					}
    				},
    				1,
    				1,
    				TimeUnit.SECONDS);
    
    
    	}
    }
    

    展开全文
  • 通 信 姓 名 学 号 指导教师 老师 目录 摘要 PAGE I 摘要 PAGE I 摘 要 本设计是在掌握了单片机及其仿真系统的使用方法的基础上综合应用单片机原理微机原理等课程方面的知识设计一个采用80C51单片机控制的交通灯控制...
  • 交通灯系统(java实现;对每个程序员来说没有学不会的技术只是没有那么多的时间与精力如果能用最少的时间学透自己想要的技术是程序员感到最幸福的事情 程序员要学的知识细节实在太多程序员要把一个知识完全搞明白所走...
  • 红灯短暂而生命长久(小学生交通安全知识演讲稿) 随着经济的日益发展,平湖已变得越来越美丽,马路上车辆川流不息的景象随处可见。然而由于有些人交通 安全意识的淡薄,在车水马龙的马路上演了一幕幕不可挽回的悲剧...
  • 交通灯管理系统

    2014-06-02 23:59:00
     交通灯管理系统 知识概要: (1)交通灯管理系统需求分析: (2)交通灯管理系统图例说明 (3)面向对象的分析与设计 (4)Road类的编写 (5)Lamp类的编写 (6...
    

    交通灯管理系统


    知识概要:

                    (1)交通灯管理系统需求分析:

                    (2)交通灯管理系统图例说明

                    (3)面向对象的分析与设计

                    (4)Road类的编写

                    (5)Lamp类的编写

                    (6)LampController类的编写

                    (7)MainClass类的编写

    交通灯管理系统需求分析:


    交通灯管理系统图例说明

    面向对象的分析与设计


    设计一个Road类来表示路线

    每个Road对象代表一条路线,总共有12条路线

    即系统中总共要产生12个Road实例对象

    每条路线上随机增加新的车辆,增加到一个集合中保存。

    每条路线每隔1秒都会检查控制本路线的灯是否为绿

    是,则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。



    设计一个Lamp类来表示一个交通灯共有12条路线,所以,系统中总共要产生12个交通灯

    每个交通灯都维护一个状态:亮(绿)或不亮(红),每个交通灯要有变亮和变黑的方法,并且能返回自己的亮黑状态。

    右拐弯的路线本来不受灯的控制

    但是为了让程序采用统一的处理方式,故假设出有四个右拐弯的灯

    只是这些灯为常亮状态,即永远不变黑。
    除了右拐弯方向的其他8条路线的灯,它们是两两成对的,可以归为4组

    所以,在编程处理时,只要从这4组中各取出一个灯,对这4个灯依次轮询变亮

    与这4个灯方向对应的灯则随之一同变化,因此Lamp类中要有一个变量来记住自己相反方向的灯

    在一个Lamp对象的变亮和变黑方法中,将对应方向的灯也变亮和变黑。

    每个灯变黑时,都伴随者下一个灯的变亮,Lamp类中还用一个变量来记住自己的下一个灯。
    无论在程序的什么地方去获得某个方向的灯时,每次获得的都是同一个实例对象

    所以Lamp类改用枚举来做显然具有很大的方便性,永远都只有代表12个方向的灯的实例对象。
    设计一个LampController类,它定时让当前的绿灯变红。

    Road类的编写

    package com.isoftstone.interview.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;
    
    /**
     * 每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。
     * 每条路线上随机增加新的车辆,增加到一个集合中保存。
     * 每条路线每隔一秒都会检查控制本路线的灯是否为绿,是则将本路线保存车的集合中的第一辆车移除,即表示车穿过了路口。
     * @author 张孝祥 www.it315.org
     *
     */
    public class Road {
    	private List<String> vechicles = new ArrayList<String>();
    	
    	private  String name =null;
    	
    	public Road(String name){
    		this.name = name;
    		
    		//模拟车辆不断随机上路的过程		
    		ExecutorService pool = Executors.newSingleThreadExecutor();
    		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();
    					}
    					vechicles.add(Road.this.name + "_" + i);
    				}				
    			}
    			
    		});
    		
    		//每隔一秒检查对应的灯是否为绿,是则放行一辆车		
    		ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
    		timer.scheduleAtFixedRate(
    				new Runnable(){
    					public void run(){
    						if(vechicles.size()>0){
    							boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
    							if(lighted){
    								System.out.println(vechicles.remove(0) + " is traversing !");
    							}
    						}
    						
    					}
    				},
    				1,
    				1,
    				TimeUnit.SECONDS);
    		
    	}
    }
    

    Lamp类的编写

    <strong>package com.isoftstone.interview.traffic;
    
    /**
     * 每个Lamp元素代表一个方向上的灯,总共有12个方向,所有总共有12个Lamp元素。
     * 有如下一些方向上的灯,每两个形成一组,一组灯同时变绿或变红,所以,
     * 程序代码只需要控制每组灯中的一个灯即可:
     * s2n,n2s    
     * s2w,n2e
     * e2w,w2e
     * e2s,w2n
     * s2e,n2w
     * e2n,w2s
     * 上面最后两行的灯是虚拟的,由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制,
     * 所以,可以假想它们总是绿灯。
     * @author 张孝祥 www.it315.org
     *
     */
    /**/
    
    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),
    	
    	/*由南向东和由西向北等右拐弯的灯不受红绿灯的控制,所以,可以假想它们总是绿灯*/
    	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;
    	
    	public boolean isLighted(){
    		
    		return lighted;
    	}
    	
    	//枚举对象带参数的构造函数
    	
    	private Lamp(String opposite,String next,boolean lighted){
    		
    		this.opposite = opposite;
    		this.next = next;
    		this.lighted = lighted;
    	}
    
    
    
    	
    	/**
    	 * 某个灯变绿时,它对应方向的灯也要变绿
    	 */	
    	
    	public void light(){
    		this.lighted = true;
    		if(opposite != null){
    			Lamp.valueOf(opposite).light();
    		}
    		System.out.println(name() + " lamp is green,下面总共应该有6个方向能看到汽车穿过!");
    		
    	}
    	
    	/**
    	 * 某个灯变红时,对应方向的灯也要变红,并且下一个方向的灯要变绿
    	 * @return 下一个要变绿的灯
    	 */
    	
    	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;
    	}
    }
    </strong>


    LampController类的编写

    <span style="font-size:18px;"><strong>package com.isoftstone.interview.traffic;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class LampController {
    	
    	private Lamp currentLamp;
    	
    	public LampController(){
    		//刚开始让由南向北的灯变绿;		
    		currentLamp = Lamp.S2N;
    		currentLamp.light();
    		
    		/*每隔10秒将当前绿灯变为红灯,并让下一个方向的灯变绿*/		
    		ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
    		timer.scheduleAtFixedRate(
    				new Runnable(){
    					public  void run(){
    						System.out.println(currentLamp.name()+"马上变红,请注意");
    						currentLamp = currentLamp.blackOut();
    				}
    				},
    				10,
    				10,
    				TimeUnit.SECONDS);
    	}
    }
    </strong></span>


    MainClass类编写

    package com.isoftstone.interview.traffic;
    
    public class MainClass {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		/*产生12个方向的路线*/		
    		String [] directions = new String[]{
    				"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"		
    		};
    		for(int i=0;i<directions.length;i++){
    			new Road(directions[i]);
    		}
    		
    		/*产生整个交通灯系统*/		
    		new LampController();
    	}
    
    }
    


    个人总结:本系统比较详细的运行了面向对象思想编程,将以往知识点综合在一起运行,要求Java功底比较扎实。

    另外:本系统还有不是特别完善的地方。接下来可以根据自己的观点将车辆的产生利用线程的方式改进而不是for循环。



    

    转载于:https://www.cnblogs.com/thankyou/p/4352143.html

    展开全文
  • 利用数电所学知识,将计数器,译码器,与非门有机组合。首先,用555定时器产生1s脉冲,将其分别给5片74LS90的脉冲输入,再将5片74LS90和数码管相连。然后再将1s脉冲通过计数器变成5s脉冲给74LS163,再将74LS163和74...
  • 例程5 交通灯

    2018-09-10 07:54:52
     上面我们已经完成了多个小灯的控制实验,接下来我们做一个相对简单点的交通灯实验,来巩固上节课控制灯的知识。我们完成这个实验所需的元件除了Arduino 控制器和下载线还需要的硬件如下: 直插LED*3  220Ω电阻...
  • 51_交通灯

    2019-10-11 12:02:27
    LCD1602+交通灯 protues电路仿真 仿真元器件 LCD:LM016L LED 仿真电路截图 硬件说明 1.LCD 1.1 引脚定义 1.2 基本操作时序: 读状态 输入:RS=L,RW=H,E=H 输出:DB0~DB7=...
  • 交通灯管理

    2011-06-28 22:17:00
    今天下午学习了交通灯管理系统,刚开始觉得毫无头绪,在跟着视频理清了头绪后,豁然开朗。感觉进步了好多,视频提供了PPT,这里就不贴上了,晚上自己再根据视频讲解,自己做一遍,看看能做出来不,主要是枚举的应用...
  • 基于FPGA的交通灯设计

    千次阅读 2019-12-04 23:18:59
    简易交通灯系统的设计与实现 最近期末了,听说很多人都在为数电大作业着急,分享一个自己做的交通灯,详细过程可以私聊我,也可以为你的设计出谋划策。其实课程之所以有这样一个要求,主要是想让大家能学以致用,将...
  • 因此本文在EDA技术的基础上,利用FPGA的相关知识设计了交通灯控制系统,可以根据实际情况对灯亮时间进行自由调整,整个设计系统通过Max+PlusⅡ软件进行了模拟仿真,并到FPGA器件中进行硬件的调试,验证了设计的交通...
  • 利用所学的《微机系统原理与接口技术》知识设计一个十字路口模拟交通灯。要求如下: (1)所设计的模拟交通灯为一个十字路口的交通灯,只有两个方向,例如东西,南北两个方向,用红、绿灯来控制两个方向的交通。
  • 交通灯项目视频总结

    2011-06-11 22:18:00
    交通灯项目视频总结 知识点:主要涉及到集合类、枚举和多线程 主要涉及的类有:1)Road类:来表示路线,每个Road对象代表一条路线,总共有12条路线,即系统中总共要产生12个Road实例对象。2)Lamp类:表示一个交通...
  •                           摘要:     近年来随着科技的飞速发展,单片机的应用正在不断深入,同时带动传统...靠的就是交通信号的自动指挥系统。交通信号控制方式很多。本系统采用MSC-51系列单片机
  • 交通灯在这个交通环境中起着一个重要的角色,是交通管理部门管理交通的重要工具。十字路口的红绿灯指挥着行人和各种车辆的安全运行。智能的交通灯能有效地缓解城市的交通压力,减少交通事故;为人民节省大量出行时间...
  • 这样得到的结论,可以让你学到知识,但是却培养不了你的逻辑思维能力。不是不能问,而是要在认真思考的基础上再发问。 有同学有疑问,板子上只有 8 个流水,那如果我要做很多个流水一起花样显示怎么办呢?那我们...
  • C51单片机技术应用与实践 第二篇 单片机基础篇 课程内容 理论 实践 任务1 点亮交通灯 理论认知 问题提出 理论认知 十字路口交通灯模型 理论认知 任务从简单到复杂从单一到综合亮单灯闪烁单灯跑马灯数码管动态显示...
  • 单片机交通灯课程设计 单片机交通灯设计(含箭头指示) 大家好,我是Alex,这篇文章是我做课程设计总结后想拿出来跟大家分享。我在完成交通灯的基本显示后,我对任务提出了更高的要求,增加了交通灯箭头显示,由于我...
  • 交通灯这个实践课基本没有什么新的知识要介绍,仍然是我们的LED灯的使用,不同的是我们使用的LED灯是一个共阳极(共正极)的三色LED灯。而且我们知道路口两边同一直线上的红绿灯是同步的,同时亮起红灯同时亮起绿灯...
  • 在这个项目中,你将使用计算机视觉技术的知识交通信号图像建立一个分类器!你会获得一个交通信号图像数据集,里面包含三种交通信号,即红灯、黄灯或绿灯,其中,三分之一的是亮起的 在该 notebook 中,你...
  • ----------------------交通灯管理系统知识总结:交通灯管理系统的项目需求:模拟实现十字路口的交通灯管理系统逻辑,具体需求如下。1,异步随机生成按照各个路线行驶的车辆。例如:由南向而来去往北向的车辆----...
  • 交通灯管理系统》

    2015-03-17 23:28:49
     看了张老师的《破解交通灯管理系统》的视频,收获良多:  1、了解了面向对象的设计方法,运用面向对象思想设计程序时,一个核心的要领是“谁拥有数据,谁就对外提供操作这些数据的方法”;  2、通过学习项目,...
  • 黑马程序员 交通灯

    2013-11-19 12:53:53
    ---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流! ----------------------  初次接触这个项目的...听得时候思路还是很清晰的,但是写的时候不是那么容易的,特别是接触到新的知识的时候,
  • 交通安全知识演讲稿范文 只要大家始终把交通安全牢记在心,落实到行动,我相信,我们完全可以远离交通事故,*是小编为大家整理的交通安全知识演讲稿,仅供参考借鉴,希望可以帮助到大家。交通安全知识演讲稿范文(一)...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 295
精华内容 118
关键字:

交通灯知识