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,String next,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() + " 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;
        }
}

控制类
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(){
                                                
                                                currentLamp = currentLamp.blackOut(); //还有这调用这个方法之后，
                                }
                                },
                                10,
                                10,
                                TimeUnit.SECONDS);
        }
}

if(opposite != null){//由于此处已判断对应的灯是否为空,所以不会一直调用方法.例如南到北,对应的灯是北到南,而北转南是没有对应的灯的,在定义枚举时已有说明 ,如下  
S2N("N2S","S2W",false),N2S(null,null,false)
                        Lamp.valueOf(opposite).light();  //

                }

if(next != null){   //判断当前枚举对象是否有下一个灯
                        nextLamp = Lamp.valueOf(next);//有下一个灯的话,返回下一个灯的枚举对象.
                        System.out.println("绿灯从" + name() + "-------->切换为" + next);                        
                        nextLamp.light();//把下一个灯变绿.
                }
return nextLamp; //并且返回下个灯的枚举对象

ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
                timer.scheduleAtFixedRate(
                                new Runnable(){
                                        public  void run(){
                                                
                                                currentLamp = currentLamp.blackOut(); //调用此方法之后,当前灯变红,下一个灯变绿,同时返回下一灯的对象,赋值给currentLamp,每隔10秒,currentLamp灯又变红,下一个灯变绿,一直循环下去.
                                }
                                },
                                10,
                                10,
                                TimeUnit.SECONDS);
        }
}

   private Lamp(String opposite,String next,boolean lighted){
                this.opposite = opposite;
                this.next = next;
                this.lighted = lighted;
        }

事实上你仔细观察一下他的构造函数就会发现问题所在了。
构造函数需要三个参数，而第一个是我们关心的问题，他到底是什么呢。他就是判断是否有相对的方向。老师在视频里讲的很清楚。只有四个方向是有相对的方向的： S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
也就是这几个，而其他的都为null。不知道说到这里你是否理解了。其实这个问题老师在视频里讲的很清楚，之所以这样设计是为了防止方法递归进入死循环。

周兴中 发表于 2012-6-26 00:06
if(opposite != null){//由于此处已判断对应的灯是否为空,所以不会一直调用方法.例如南到北,对应的灯是北到 ...

if(next != null){   //判断当前枚举对象是否有下一个灯
                                                                                                //如果下个灯是空又该怎么走？
                        nextLamp = Lamp.valueOf(next);//有下一个灯的话,返回下一个灯的枚举对象.
                        System.out.println("绿灯从" + name() + "-------->切换为" + next);                        
                        nextLamp.light();//把下一个灯变绿.
                }
return nextLamp; //并且返回下个灯的枚举对象

Forever。 发表于 2012-6-26 00:15
private Lamp(String opposite,String next,boolean lighted){
                this.opposite = opposi ...

这个我明白，其实我问的不是这，  如果下个灯为空，又该怎么走，我的意思是说,当下个灯不是由南到北，还是由南往西的话，那下个灯就等于null了吧 那就进入不了这个判断。。。。。if(next != null){  
                        nextLamp = Lamp.valueOf(next);
                        System.out.println("绿灯从" + name() + "-------->切换为" + next);                        
                        nextLamp.light();
                }
return nextLamp; 。又该怎么走？？？？？

sunhaodi 发表于 2012-6-26 00:46
这个我明白，其实我问的不是这，  如果下个灯为空，又该怎么走，我的意思是说,当下个灯不是由南到北，还 ...

其实在灯的枚举中已经把next定义了，不会出现你说的下一个等为空。

sunhaodi 发表于 2012-6-26 00:42
if(next != null){   //判断当前枚举对象是否有下一个灯
                                              ...

S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),

下一个灯是不会为空的,一直循环,你要注意观察定义的枚举对象,前四个是循环亮的. 南到北-->南到西-->东到西-->东到南-->南到北......一直循环.