1. Lamp类的编写


package com.isoftstone.interview;

/**
 * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
 * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
 * 程序代码只需要控制每组灯中的一个灯即可：
 * s2n,n2s    
 * s2w,n2e
 * e2w,w2e
 * e2s,w2n
 * s2e,n2w
 * e2n,w2s
 * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，所以，可以假想它们总是绿灯。
 */
public enum Lamp {

  /*每个枚举元素各表示一个方向的控制灯*/
  S2N("N2S","S2W",false),S2W("E2N","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),N2W(null,null,true),W2S(null,null,true),E2N(null,null,true);

  /*当前灯是否亮着，即是否为绿灯*/  
  private boolean lighted;
  /*与当前灯同时为绿的对应方向*/ 
  private String opposite;
  /*当前灯变红时下一个变绿的灯*/ 
  private String next;

  //带以上三个参数的构造方法
  private Lamp(String opposite, String next,boolean lighted) {
    this.opposite = opposite;
    this.next = next;
    this.lighted = lighted;
  }

  /**
   * 判断是否为绿灯的方法
   * @return
   */
  public boolean isLighted(){
    return lighted;
  }

  /**
   * 某个灯变绿时，它对应方向的灯也要变绿
   */ 
  public void light(){
    this.lighted = true;
    //如果opposite为null则使改方法死循环，就是一直亮着绿灯
    if(opposite != null){
      /*valueOf()方法为枚举类自带的方法;把字符串名字传进去返回对应的枚举对象；
       * 可能有的人会说为什么不直接把opposite变量定义成枚举Lamp型；
       * 这里笔者这么考虑：如果定义成Lamp型，那么上面的S2N这些属性变量
       * 里面不方便传值，改成现在这样写，即将opposite定义成String型的，
       * 直接给这些属性变量传入一个字符串即可，方便了很多
       */
      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);
      //name()方法也是枚举类自带的方法，返回一个自身属性名
      System.out.println("绿灯从" + name() + "-------->切换为" + next);
      nextLamp.light();
    }
    return nextLamp;
  }

}

2. Road类的编写

package com.isoftstone.interview;

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实例对象。
 * 每条路线上随机增加新的车辆，增加到一个集合中保存。
 * 每条路线每隔一秒都会检查控制本路线的灯是否为绿，是则将本路线保存车的集合中的第一辆车移除，即表示车穿过了路口。
 */
public class Road {

  //vehicles代表车俩，是个车俩集合，包括大卡车、小驾车等等所有车俩
  List<String> vehicles = new ArrayList<String>();
  //name成员变量表示方向
  String name = null;

  public Road(String name){
    this.name = name;

    //模拟车辆不断随机上路的过程
    /*Executors是jdk5新特性中的执行器，可以这么记：我们起的工具类比如utils都是以s结尾，
     * 改类如何用如何拼写必须记住，Executors类似,改类有大量的静态方法；改执行器可以new多种线程池，
     * 当然也可以new出下面的单独线程，不管是线程池还是线程都返回一个ExecutorService类型的值
     */
    ExecutorService executor = Executors.newSingleThreadExecutor();
    //Runnable是接口不能直接new出但是可以将其弄成内部类new出其的实现类
    executor.execute(new Runnable() {

      @Override
      public void run() {
        //产生999辆车
        for(int i=1;i<1000;i++){
          try {
            //休息1到10秒随机时间
            Thread.sleep((new Random().nextInt(10) + 1) * 1000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          /*内部类访问外部的成员变量可以讲外部类的改成员变量弄错final最终的，
          也可以在内部类中使用外部类名.this.外部类变量的方法达到目的*/
          vehicles.add(Road.this.name + "_" + i);
        }
      }
    });

    //每隔一秒检查对应的灯是否为绿，是则放行一辆车
    //定时器（连环爆炸器）的编写，应用相当广泛，必会；new的是Scheduled（调度）调度池
    ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
    timer.scheduleAtFixedRate(new Runnable() {

      @Override
      public void run() {
        //先检查路上有没有车辆
        if(vehicles.size()>0){
          boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
          if(lighted){
            //traversing:正在穿过
            System.out.println(vehicles.remove(0) + " is traversing !");
          }
        }
      }
    },  
    1,  //过多少时间去干这件事
    1,  //隔多少时间再去干这件事
    TimeUnit.SECONDS);//说明上面数值的定量单位，是隔1秒呢还是1分钟或1小时呢;
  }


}

3. LampController类的编写

package com.isoftstone.interview;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 车辆控制器，主要操作对象
 */
public class LampController {

  private Lamp currentLamp;

  public LampController(){
    //刚开始让由南向北的灯变绿;
    currentLamp = Lamp.S2N;
    currentLamp.light();

    /*每隔10秒将当前绿灯变为红灯，并让下一个方向的灯变绿*/
    Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

      @Override
      public void run() {
        System.out.println("车辆有本事你来啊！");
        currentLamp = currentLamp.blackOut();
      }
    }, 
    10, 
    10,
    TimeUnit.SECONDS);

  }

}

4. MainClass类的编写

package com.isoftstone.interview;

public class MainClass {

  /**
   * @param args
   */
  public static void main(String[] args) {
    /*产生12个方向的路线*/  
    String[] directions = {"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();
  }

}