interface Incrementable {
     void increment();
}

class Callee1 implements Incrementable {
    private int i = 0;
    public void increment() {
    i++;
    System.out.println(i);
    }
}

class MyIncrement {
   public void increment() { System.out.println("Other operation"); }
   static void f(MyIncrement mi) { mi.increment(); }
}

class Callee2 extends MyIncrement {
    private int i = 0;
    public void increment() {
    super.increment();
    i++;
    System.out.println(i);
   }
   private class Closure implements Incrementable {
      public void increment() {
      Callee2.this.increment();
      }
   }
Incrementable getCallbackReference() {
    return new Closure();
    }
}

class Caller {
    private Incrementable callbackReference;
    Caller(Incrementable cbh) { callbackReference = cbh; }
    void go() { callbackReference.increment(); }
}

public class Callbacks {
    public static void main(String[] args) {
         Callee1 c1 = new Callee1();
         Callee2 c2 = new Callee2();
         MyIncrement.f(c2);
         Caller caller1 = new Caller(c1);
         Caller caller2 = new Caller(c2.getCallbackReference());
         caller1.go();
         caller1.go();
         caller2.go();
         caller2.go();
    }
}

天啊，怎么那么长都没有注释呢！强烈请求加注释！谢谢

eycrckag 发表于 2013-5-11 22:38
天啊，怎么那么长都没有注释呢！强烈请求加注释！谢谢

原文没注释啊，不便之处，敬请见谅！

复制下来，自己运行一次不就可以了。

想说下哪里找来的题目，这么复杂....扯淡啊，你要是初学者就别看了，我足足分析了一个半小时，为你加了注释。
就差没有画内存分析图。如果没有画内存分析图的话，这一题非常容易出错。

1. package generic;
   
2. 
   
3. /**
   
4. *
   
5. * @author Administration
   
6. *
   
7. */
   
8. 
   
9. interface Incrementable
   
10. {
    
11. 
    
12.         /**
    
13.          * Incrementable接口中定义一个增加的方法
    
14.          */
    
15.         void increment();
    
16. }
    
17. 
    
18. class Callee1 implements Incrementable// Callee1实现了Incrementable接口，复写increment()方法
    
19. {
    
20.         private int i = 0;
    
21. 
    
22.         /*
    
23.          * 复写的方法 (non-Javadoc)
    
24.          *
    
25.          * @see generic.Incrementable#increment()
    
26.          */
    
27.         public void increment()
    
28.         {
    
29.                 i++;
    
30.                 System.out.println("Callee1---" + i);
    
31.         }
    
32. }
    
33. 
    
34. /**
    
35. *
    
36. * @author Administration 定义一个普通类
    
37. *
    
38. */
    
39. class MyIncrement
    
40. {
    
41.         /**
    
42.          * 定义了一个方法increment()
    
43.          */
    
44.         public void increment()
    
45.         {
    
46.                 System.out.println("MyIncrement------Other operation");
    
47.         }
    
48. 
    
49.         /**
    
50.          * 定义了一个静态方法，实现调用本类的increment（）方法
    
51.          *
    
52.          * @param mi
    
53.          */
    
54.         static void f(MyIncrement mi)// 传入一个c2变量
    
55.         {
    
56.                 mi.increment();
    
57.         }
    
58. }
    
59. 
    
60. /**
    
61. *
    
62. * @author Administrator 一个普通类Callee2继承了 MyIncrement类
    
63. *
    
64. */
    
65. class Callee2 extends MyIncrement
    
66. {
    
67.         private int i = 0;
    
68. 
    
69.         /**
    
70.          * 复写了increment（）方法
    
71.          */
    
72.         public void increment()
    
73.         {
    
74.                 super.increment();// 调用父类的方法
    
75.                 i++;
    
76.                 System.out.println("MyIncrement----" + i);
    
77.         }
    
78. 
    
79.         /**
    
80.          *
    
81.          * @author Administrator 定义了一个内部类实现了Incrementable接口，需要覆盖increment()方法
    
82.          */
    
83.         private class Closure implements Incrementable
    
84.         {
    
85.                 public void increment()
    
86.                 {
    
87.                         Callee2.this.increment();// 内部类调用外部类方法，称为回调
    
88.                 }
    
89.         }
    
90. 
    
91.         Incrementable getCallbackReference()
    
92.         {
    
93.                 return new Closure();// 新建了Closure的实例对象，然后将其返回
    
94.         }
    
95. }
    
96. 
    
97. class Caller
    
98. {
    
99.         private Incrementable callbackReference;// 定义了一个接口类型的变量
    
100. 
     
101.         /**
     
102.          * 通过构造方法初始化Incrementable 类型变量的值
     
103.          *
     
104.          * @param cbh
     
105.          */
     
106.         Caller(Incrementable cbh)
     
107.         {
     
108.                 callbackReference = cbh;
     
109.         }
     
110. 
     
111.         /**
     
112.          * 通过该初始化后的对象调用increment()方法，有可能存在多态，要看具体传入的值
     
113.          */
     
114.         void go()
     
115.         {
     
116.                 callbackReference.increment();
     
117.         }
     
118. }
     
119. 
     
120. public class Callbacks
     
121. {
     
122.         public static void main(String[] args)
     
123.         {
     
124.                 Callee1 c1 = new Callee1();// 新建了一个Callee1的对象，马上去查看该类是否有父类，
     
125.                 // 有则先调用父类的无参构造方法，然后才调用本类的构造方法。有多个间接父类也是一样的。由于都没有实现构造方法所以没有输出结果
     
126.                 Callee2 c2 = new Callee2();// 由于MyIncrement与Cllee2都没有实现默认的构造方法，所以什么也没有输出
     
127.                 MyIncrement.f(c2);// 先输出：MyIncrement------Other operation
     
128.                                                         // 然后输出：MyIncrement----1，
     
129.                                                         // 存在多态的现象，调用的Collee2类中的increment()方法。
     
130.                 Caller caller1 = new Caller(c1);// 没有构造函数所以没有输出
     
131.                 Caller caller2 = new Caller(c2.getCallbackReference());// c2.getCallbackReference()返回new
     
132.                                                                                                                                 // Closure();
     
133.                                                                                                                                 // 然后：callbackReference
     
134.                                                                                                                                 // = new
     
135.                                                                                                                                 // Closure();存在多态
     
136.                 caller1.go();// 存在多态所以调用的是Collee1中的increment()方法输出：Callee1---1
     
137.                 caller1.go();// 同一个对象调用go()所以输出：Callee1---2
     
138.                 caller2.go();// 存在多态调用的是Callee2的内部类Closure中的increment（）方法：输出MyIncrement------Other
     
139.                                                 // operation MyIncrement----2(由于前面的MyIncrement.f(c2)已经输出：MyIncrement----1)
     
140.                 caller2.go();// 统一对象调用两次：输出MyIncrement------Other operation
     
141.                                                 // MyIncrement----3
     
142.         }
     
143. }
     

复制代码

潘廖明 发表于 2013-5-12 01:41
想说下哪里找来的题目，这么复杂....扯淡啊，你要是初学者就别看了，我足足分析了一个半小时，为你加了注释 ...

神人啊，再次膜拜！万分感谢！