Java内部类(5)：应用例

例1-闭包(Closure)

闭包是一个可调用的对象(通过Callback)，它记录了一些信息，这些信息来自于创建它的作用域

 interface Incrementable {
     void increment();
 }

 class Callee1 implements Incrementable {
     private int i = 0;

     @Override
     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;

     @Override
     public void increment() {
         super.increment();
         i++;
         System.out.println(i);
     }

     private class Closure implements Incrementable {
         @Override
         public void increment() {
             Callee2.this.increment();
         }
     }

     Incrementable callBack() {
         return new Closure();
     }
 }

 class Caller {
     private Incrementable callbackReference;

     Caller(Incrementable callbackReference) {
         this.callbackReference = callbackReference;
     }

     void go() {
         callbackReference.increment();
     }
 }

 /**
  * 关键字: 内部类应用, 闭包(Closure)<br/>
  * 1.闭包是一个可调用的对象(通过Callback)，它记录了一些信息，这些信息来自于创建它的作用域<br/>
  */
 public class Test007 {

     public static void main(String[] args) {
         Callee1 c1 = new Callee1();
         c1.increment(); //
         Callee2 c2 = new Callee2();
         MyIncrement.f(c2); // Other operation|1
         Caller caller1 = new Caller(c1);
         caller1.go(); //
         Caller caller2 = new Caller(c2.callBack());
         caller2.go(); // Other operation|2
     }
 }

例2-复杂情况下的调用顺序

 class Egg2 {

     protected class Yolk {
         public Yolk() {
             System.out.println("Egg2.Yolk()");
         }

         public void f() {
             System.out.println("Egg2.Yolk.f()");
         }
     }

     private Yolk y = new Yolk();

     public Egg2() {
         System.out.println("New Egg2()");
     }

     public void insertYolk(Yolk yy) {
         y = yy;
     }

     public void g() {
         y.f();
     }
 }

 class Test008Sub extends Egg2 {
     public Test008Sub() {
         System.out.println("AA");
         insertYolk(new Yolk());
     }

     public class Yolk extends Egg2.Yolk {
         public Yolk() {
             System.out.println("BigEgg2.Yolk()");
         }

         public void f() {
             System.out.println("BigEgg2.Yolk.f()");
         }
     }
 }

 // 复杂情况下的调用顺序
 public class Test008 {
     public static void main(String[] args) {
         new Test008Sub().g();
         // Egg2.Yolk()
         // New Egg2()
         // AA
         // Egg2.Yolk()
         // BigEgg2.Yolk()
         // BigEgg2.Yolk.f()
     }
 }