1. public void light(){
   
2.                 this.lighted = true;
   
3.                 if(opposite != null){
   
4.                         Lamp.valueOf(opposite).light();
   
5.                 }
   
6.                 System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
   
7.                
   
8.         }

复制代码

Lamp.valueOf(opposite).light();这句代码中，valueOf(oppsite)这个函数的定义是什么？怎么理解？

light()方法所在的类叫什么,Lamp.valueOf()方法返回的类型就是什么,现在我们假定Lamp.valueOf()方法返回的类型是个Temp类.而oppsite是什么类的引用,我也不知道,现在假设oppsite是Oppsite类的对象的引用,那就可以做如下推断:

1. class Temp {
   
2. 
   
3.         // 一个boolean型变量lighted.
   
4.         boolean lighted = false;
   
5. 
   
6.         Opposite opposite = null;
   
7. 
   
8.         public void light() {
   
9.                 this.lighted = true;
   
10.                 if (opposite != null) {
    
11.                         Lamp.valueOf(opposite).light();
    
12.                 }
    
13.                 System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
    
14.         }
    
15. 
    
16.         public String name() {
    
17.                 // return 一个字符串;
    
18.         }
    
19. 
    
20. }
    
21. 
    
22. class Opposite {
    
23. 
    
24.         // Opposite类该有些什么,我就不知道了,我还没有看那个视频.
    
25. 
    
26. }

复制代码

补充一下:

1. class Lamp {
   
2. 
   
3.         public static Temp valueOf(Opposite opposite) {
   
4.                 // ......
   
5. 
   
6.                 // return 一个Temp类的对象
   
7.         }
   
8. 
   
9. }
   
10. 
    
11. class Temp {
    
12. 
    
13.         // 一个boolean型变量lighted.
    
14.         boolean lighted = false;
    
15. 
    
16.         Opposite opposite = null;
    
17. 
    
18.         public void light() {
    
19.                 this.lighted = true;
    
20.                 if (opposite != null) {
    
21.                         Lamp.valueOf(opposite).light();
    
22.                 }
    
23.                 System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
    
24.         }
    
25. 
    
26.         public String name() {
    
27.                 // return 一个字符串;
    
28.         }
    
29. 
    
30. }
    
31. 
    
32. class Opposite {
    
33. 
    
34.         // Opposite类该有些什么,我就不知道了,我还没有看那个视频.
    
35. 
    
36. }

复制代码

light()方法所在的类叫什么,Lamp.valueOf()方法返回的类型就是什么,现在我们假定Lamp.valueOf()方法返回的 ...

Lamp.valueOf(opposite)感觉是得到此Lamp枚举的opposite属性的值，opposite的只是另外一个Lamp的枚举。感觉是这样子的，想找到这个valueOf函数。

Lamp是枚举。它自身没有valueOf这个方法，枚举类倒是有valueOf方法，但是是2个参数的，纠结。

给你贴这个Lamp.java全部代码：

1. package com.isoftstone.interview.traffic;
   
2. 
   
3. /**
   
4. * 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
   
5. * 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
   
6. * 程序代码只需要控制每组灯中的一个灯即可：
   
7. * s2n,n2s   
   
8. * s2w,n2e
   
9. * e2w,w2e
   
10. * e2s,w2n
    
11. * s2e,n2w
    
12. * e2n,w2s
    
13. * 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，
    
14. * 所以，可以假想它们总是绿灯。
    
15. * @author 张孝祥 www.it315.org
    
16. *
    
17. */
    
18. /**/
    
19. 
    
20. public enum Lamp {
    
21.         /*每个枚举元素各表示一个方向的控制灯*/        
    
22.         S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
    
23.         /*下面元素表示与上面的元素的相反方向的灯，它们的“相反方向灯”和“下一个灯”应忽略不计！*/
    
24.         N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
    
25.         /*由南向东和由西向北等右拐弯的灯不受红绿灯的控制，所以，可以假想它们总是绿灯*/
    
26.         S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
    
27.         
    
28.         private Lamp(String opposite,String next,boolean lighted){
    
29.                 this.opposite = opposite;
    
30.                 this.next = next;
    
31.                 this.lighted = lighted;
    
32.         }
    
33. 
    
34. 
    
35.         /*当前灯是否为绿*/        
    
36.         private boolean lighted;
    
37.         /*与当前灯同时为绿的对应方向*/        
    
38.         private String opposite;
    
39.         /*当前灯变红时下一个变绿的灯*/        
    
40.         private String next;
    
41.         public boolean isLighted(){
    
42.                 return lighted;
    
43.         }
    
44.         
    
45.         /**
    
46.          * 某个灯变绿时，它对应方向的灯也要变绿
    
47.          */        
    
48.         public void light(){
    
49.                 this.lighted = true;
    
50.                 if(opposite != null){
    
51.                         Lamp.valueOf(opposite).light();
    
52.                 }
    
53.                 System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
    
54.                
    
55.         }
    
56.         
    
57.         /**
    
58.          * 某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿
    
59.          * @return 下一个要变绿的灯
    
60.          */        
    
61.         public Lamp blackOut(){
    
62.                 this.lighted = false;
    
63.                 if(opposite != null){
    
64.                         Lamp.valueOf(opposite).blackOut();
    
65.                 }               
    
66.                
    
67.                 Lamp nextLamp= null;
    
68.                 if(next != null){
    
69.                         nextLamp = Lamp.valueOf(next);
    
70.                         System.out.println("绿灯从" + name() + "-------->切换为" + next);                        
    
71.                         nextLamp.light();
    
72.                 }
    
73.                 return nextLamp;
    
74.         }
    
75. }
    

复制代码

寇龙飞 发表于 2012-9-3 16:37
Lamp.valueOf(opposite)感觉是得到此Lamp枚举的opposite属性的值，opposite的只是另外一个Lamp的枚举。感 ...

valueOf()方法是有可能是枚举,反正我没看那视频,就不猜了.