Lamp 设计成这样  怎么不行啊
        S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","N2S",false),
        N2S("S2N","N2E",false),  N2E("S2W","W2E",false),  W2E("E2W","W2N",false),  W2N("E2S","S2N",false),
        S2E(null,null,true),   E2N(null,null,true),  N2W(null,null,true),   W2S(null,null,true);
         

{:soso_e127:}你设计成这样，用张老师的程序估计是死循环吧

神之梦 发表于 2013-9-8 22:45
你设计成这样，用张老师的程序估计是死循环吧

我感觉不会出现死循环，但事实就是死循环， 其他代码和老师的一样，这么写到底哪的问题啊

sylar 发表于 2013-9-8 22:52
我感觉不会出现死循环，但事实就是死循环， 其他代码和老师的一样，这么写到底哪的问题啊 ...

视频中老师在讲点亮当前灯和返回下一个灯的方法时，有说过会出现死循环的，你明白了那段代码就明白了这么写的原因

public class Lamp {
        private String []directions={"东","北","西","南"};//定义一个用来表示方向的数组

        /*当前灯是否为绿*/        
        private boolean lighted;
        private String relativeLamp;
        /*与当前灯同时为绿的对应方向*/        
        private String name;
        private String LampName;
        
        public Lamp(String name){
                this.name=name;
        }
        public Lamp()
        {
                //随机产生一个方向，给交通灯进行初始化，
                int []result=Utils.SingalRradom();//用来产生方向哪个数组的下标
                //对灯进行初始化，一开始就设置灯从东西方向灯绿的，
                LampName=directions[result[0]]+directions[result[1]];
                //relativeLamp=directions[result[1]]+directions[result[0]];//对应方向上的灯也要设置为绿
                relativeLamp=this.relativeLamp();
                System.out.println("刚开始时绿灯的方位是："+LampName+"   和    "+this.relativeLamp());
        }
        
        public boolean isLighted(){
                return lighted;
        }
        //得到某个元素在数组中的位置
        private int indexof(String [] str,String element){
                int index=-1;
                for(int i=0;i<str.length;i++){
                        if(str.equals(element)){
                                index=i;
                                break;
                        }
                }
                if(index==-1){
                        System.out.println("该元素不再该数组中");
                }
                return index;
        }
        
        //返回与之相对应灯
        public String relativeLamp(){
                String lampName=this.LampName;//得到这个灯的方向，字符串形式
                String first=lampName.substring(0, 1);
                String second=lampName.substring(1, 2);
                int x=indexof(directions,first);
                int y=indexof(directions,second);
                if(!(Math.abs(x-y)==2))//如果绝对值不等于二，就说明不是直走方向的灯
                {
                        x=(x+2)%4;
                        y=(y+2)%4;
                }
                else
                {
                        int temp;
                        temp=x;
                        x=y;
                        y=temp;
                }
                return directions[x]+directions[y];
        }
        
        //返回下一个灯
        public Lamp nextLamp(){
                Lamp lamp=null;
                String lampName=this.LampName;//得到这个灯的方向，字符串形式
                String first=lampName.substring(0, 1);//得到灯开始方向
                String second=lampName.substring(1, 2);//得到灯的结束方向
                int x=indexof(directions,first);
                int y=indexof(directions,second);
                System.out.println("开始前：x="+x+"  y="+y);
                int sub=x-y;//对2求余，如果值是0，就说明是直走灯，如果值为1，就说明是左拐灯在亮
                if(sub==1||sub==-3){
                        //左拐的灯，那么下一个灯就是直走，也就是说ch[1]不变，
                        x=(++x)%4;
                }
                else if(Math.abs(sub)==2){
                        //说明当前是直走灯，那么下一个等也就是左拐灯，ch[1]+1
                        y=(++y)%4;        
                }
                else{
                        System.out.println("右拐灯，无效");
                }
                System.out.println("开始后：x="+x+"  y="+y);               
                System.out.println("下一个灯1秒后变绿："+directions[x]+directions[y]+" 以及与之对应的的："+directions[(x+2)%4]+directions[(y+2)%4]);
                lamp=new Lamp(directions[y]+directions[x]);
                return lamp;
        }

        public static void main(String []args)
        {
                Lamp l=new Lamp();
                while(true){
                        try {
                                Thread.sleep(1000);
                        } catch (InterruptedException e) {
                                System.out.println("1秒后变成下一个灯异常");
                                e.printStackTrace();
                        }
                        l=l.nextLamp();
                        System.out.println("l="+l.LampName);
                }
        }
}

public class Utils {
        //随机从0~3之间生成两个不重复的数
       
        public static int[] SingalRradom(){
                //从0~3这四个数中随机产生两个不重复的数字，通过组合来表示方向，并用这个方向给相应的车命名
                int k=2;//产生随机数的数量
                int n=4;//产生随机数的范围
                int []number=new int[n];
                for(int i=0;i<number.length;i++)
                {
                        number=i;
                }
                int [] result=new int[k];
                for(int i=0;i<result.length;i++)
                {
                        int r=(int)(Math.random()*n);
                        result=number[r];
                        number[r]=number[n-1];
                        n--;
                }
                return number;
        }
}
这是我自己想出来的关于灯的设计，你可以参考一些，我感觉比张老师的要号理解些，但是整个题我没有整出来，可能还是知识储备不够吧，我还在思索中，

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


你要结合那个交通图来理解，首先参数的理解是 方向(“相反方向”,“下一个方向”,"此方向的等是否是路灯")

根据交通等图，理解灯的变灯的顺序后，这样理解，
我们知道，有四个方向的灯是常绿的，他们没有相反他们是： S2E(null, null, true), E2N(null, null, true), N2W(null, null, true), W2S(null, null, true);
                 其他的八个方向的灯两两互为相反的方向，所以我们操作其中四个方向的等就可以，其他的就会跟着变也就可以不用指定其反方向的，因为操作的四个方向的已经指定了，


    顺序：当前方向的灯变绿（亮）或者红(黑)了，那么反方向的灯也要跟着变，同时要指定下一个方向，当前要是亮，则下一个方向的则是黑，反过来一样操作，所以要指定下一个方向，并且要标识当前灯的状况，所以要指定最后一个参数。
希望你能理解，对你有帮助！