Java语言十五讲(第七讲 InnerClass)

同学们，这一次讲座，我们讲一下Inner Class内部类。
我们平时写的程序是由一个个类构成的，这些类之间是相互独立的关系。我们说过，这种思路源自对现实世界的模拟，拉近了“问题空间”和“解决空间”。因此简化了系统的设计。
而Inner class 内部类是指一个类是另一个类的内部成员，定义在某个类的内部的，对外可能可见也可能不可见。

基本形式还是蛮简单的，我们看一个例子：

public class OuterClass {
    private String outerName;
    public void display(){
        System.out.println("OuterClass display...");
        System.out.println(outerName);
    }
    public class InnerClass{
        private String innerName;
        InnerClass(){
            innerName = "inner class";
        }
        public void display(){
               System.out.println("InnerClass display...");
            System.out.println(innerName);
        }
    }
}

如上面的代码所示，这样在OuterClass里面就定义了一个InnerClass类。使用的时候可以这么用：

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }

从代码可以看出，内部类跟一个普通属性一样使用，只要在外部类创建好的情况下，就可以去使用，可以明显看出这种被包含的关系。
而且，外部的程序能这么用的一个前提是内部类声明为public，这样才会为外部程序所见，这个跟普通属性也是一样的。当然，这个public不是约束包含的那个外部类的，无论把内部类声明为public还是private，对包含它的外部类都是可见的。

外部类和内部类的这种包含关系，决定了互相可以调用。代码如下(OuterClass.java)：

public class OuterClass {
    private String outerName;

    public OuterClass(){
        outerName="OurClass Default Name";
    }
    public void display(){
        System.out.println("OuterClass display...");
        System.out.println(outerName);
    }
    public void displayInner(){
        InnerClass innerClass=new InnerClass();
        innerClass.display();
    }

    private class InnerClass{
        private String innerName;
        InnerClass(){
            outerName="outer class new name";
            innerName = "inner class default name";
        }
        public void displayOuter(){
            System.out.println(outerName);
        }        
        public void display(){
            System.out.println("InnerClass display...");
            System.out.println(innerName);
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        outerClass.displayInner();

        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
        innerClass.displayOuter();
    }
}

我们在OuterClass里面用下面两行创建了内部类并调用方法：

        InnerClass innerClass=new InnerClass();
        innerClass.display();

而在内部类里面，我们直接使用了外部内的属性。这一段演示了外部类内部类的互操作。编译器会做一个处理，对上面的内部类方法：

public void displayOuter(){
            System.out.println(outerName);
        }  

编译之后的代码会变成：

OuterClass.this.outerName。

好奇的人一般会去bin目录下看一眼编译之后的结果，生成了两个class文件，OuterClass.class和OuterClass

除了上述的基本型内部类，内部类还可以定义成静态的，或者在一个方法体内进行定义，如：

   void method1() {
      class InnerClass {
         public void print() {
            System.out.println("method inner class.");       
         }   
      }
      InnerClass inner = new InnerClass();
      inner.print();
   }

这个简单，这里不再完整举例。下面举一个静态内部类的例子，代码如下(Employee.java)：

public class Employee{    
    public String empName;    
    public Company company;    

    public Employee(String empName){    
         this.empName = empName;    
    }    
    public static class Company{    
         public String compName;    
         public String compRegion;    

         public Company(String compName,String compRegion){    
             this.compName = compName;    
             this.compRegion = compRegion;    
         }    
    }    

    public static void main(String[] args) {    
        Company company = new Employee.Company("Sun/Oracle", "China");  
        Employee alice = new Employee("Alice");    
        Employee bob = new Employee("Bob");    
        alice.company = company;    
        bob.company = company;    
    } 
}   

上面的Employee里面包含一个静态内部类Company，这样跟一个普通类类似了，外部程序可以直接创建这个内部类。而且多个外部类employee可以共享同一个内部类company。要注意的是，这个时候，外部类可以访问内部类，而内部类访问不了外部类。你们可以自己动手试一下，在Employee中增加一个test()，然后试着在Company中调用，会有编译错误:

Cannot make a static reference to the non-static method test() from the type Employee。

有了内部类的这些基础知识，下面我们要讨论进阶一点的内容了。
有一种很有用的场合时匿名内部类。它看起来就是一个常规的内部类，但是不显式起名，因此叫匿名类。这个场景，定义和实例化是写在一起同时的。当我们需要实现一个接口或者抽象类的时候，我们经常这么用。
我们看一个监听器响应事件触发的例子。代码如下：
先定义一个Listener接口：

public interface ClickListener {
    void onClick();
}

再定义一个Button类，里面包含一个Listener匿名内部类，代码如下(Button.java)：

public class Button {
    public void click(){
        new ClickListener(){
            public void onClick(){
                System.out.println("click ...");
            }
        }.onClick();
    }
    public static void main(String[] args) {
        Button button=new Button();
        button.click();
    }
}

仔细看看上面的代码，按照常规，我们应该在click()方法中定义这个内部类，然后new一个实例，再调用方法。而使用匿名内部类，我们用一句话一气呵成：

new ClickListener(){
      public void onClick(){
          System.out.println("click ...");
      }
}.onClick();

之所以这么用，是因为其实我们只是想实现onClick()方法，至于这个类叫什么名字，我们并不关心，所以就匿名了。这种需求在些事件响应程序式会经常用到。这个匿名可以看成一种简写，对编译器来讲，他还是规规矩矩地生成了一个内部类的class文件ButtonInnerClass.class。为什么需要内部类？用两个外部类不是一样的吗？从程序功能上来说，确实是一样的。我个人理解的是，采用内部类技术，隐藏细节和内部结构，封装性更好，让程序结构更加合理优雅。在现实世界里，一个事物内部都由很多部件组成，每个部件也还可能包含子部件，这些子部件不需要暴露出来。内部类的思想就是借鉴了这个现实世界，概念的同一性让它很好理解。这种思想更贴近现实世界，“问题空间”与“解决空间”更接近了。

除了上述的基本型内部类，内部类还可以定义成静态的，或者在一个方法体内进行定义，如：¨G6G这个简单，这里不再完整举例。下面举一个静态内部类的例子，代码如下(Employee.java)：¨G7G上面的Employee里面包含一个静态内部类Company，这样跟一个普通类类似了，外部程序可以直接创建这个内部类。而且多个外部类employee可以共享同一个内部类company。要注意的是，这个时候，外部类可以访问内部类，而内部类访问不了外部类。你们可以自己动手试一下，在Employee中增加一个test()，然后试着在Company中调用，会有编译错误:¨G8G有了内部类的这些基础知识，下面我们要讨论进阶一点的内容了。有一种很有用的场合时匿名内部类。它看起来就是一个常规的内部类，但是不显式起名，因此叫匿名类。这个场景，定义和实例化是写在一起同时的。当我们需要实现一个接口或者抽象类的时候，我们经常这么用。

我们看一个监听器响应事件触发的例子。代码如下：先定义一个Listener接口：¨G9G再定义一个Button类，里面包含一个Listener匿名内部类，代码如下(Button.java)：¨G10G仔细看看上面的代码，按照常规，我们应该在click()方法中定义这个内部类，然后new一个实例，再调用方法。而使用匿名内部类，我们用一句话一气呵成：¨G11G之所以这么用，是因为其实我们只是想实现onClick()方法，至于这个类叫什么名字，我们并不关心，所以就匿名了。这种需求在些事件响应程序式会经常用到。这个匿名可以看成一种简写，对编译器来讲，他还是规规矩矩地生成了一个内部类的class文件Button1.class。
我们要的是这个方法，而接口里面也只有着一个方法，这种场景叫函数式接口，Java8之后可以用函数式编程进一步简化上面的代码：

    public void click(){
        ClickListener listener = ()->{System.out.println("click ...");};
        listener.onClick();
    }

函数式接口与匿名类是不同的实现方式。编译器并不会生成一个内部类class文件。

把匿名类当成方法的参数是常见的使用方式。
我们写一个程序，一个事件处理器响应事件的发生，响应完之后发一个消息通知。
先定义一个发消息的接口：

public interface IMessenger {
    void sendMessage(String string);
}

再定义事件处理器，代码如下(Handler.java)：

public class Handler {
    public void handleEvent(IMessenger messenger) {
        new Thread(new Runnable() {
             public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                messenger.sendMessage("SUCCESS.");
            }
        }).start();
    }
}

这个处理器的主体方法是handleEvent(IMessenger)，异步处理事件花费两秒钟，之后发消息。
下面我们使用这个事件处理器，代码如下(HandlerTest.java)：

public class HandlerTest {
    public static void main(String[] args) {
        Handler handler = new Handler();
        handler.handleEvent(new IMessenger() {
            public void sendMessage(String msg) {
                System.out.println("event handled. " + msg);
            }
        });
        System.out.println("------event handling test--------");
    }

}

注意上面代码的主体部分：

        handler.handleEvent(new IMessenger() {
            public void sendMessage(String msg) {
                System.out.println("event handled. " + msg);
            }
        });

这里就是生成了一个实现IMessenger接口的匿名类，然后传给handleEvent()方法作为参数使用。自然，编译器会自动生成一个匿名类class文件。
再一次提及函数式编程，因为这个IMessenger是一个只有唯一一个方法的接口，所以此处我们可以再次用函数式编程简化代码：

    public static void main(String[] args) {
        Handler handler = new Handler();
        handler.handleEvent((msg) ->{System.out.println("event handled. " + msg);});
        System.out.println("------event handling test--------");
    }

匿名内部类来自外部闭包环境的自由变量必须是final的。这一点让人费解，很多人在编译器提示错误的时候就自动修改一下，并不深究。这个与Java对Closure闭包的实现有关，我们来初步探究一下。这是比进阶更加高级的课题了。
闭包是包含自由变量的函数，这些变量是在定义函数的环境中定义的，而函数本身也当成一个参数进行传递和返回，返回后，这个自由变量还同函数一同存在。在JavaScript和别的语言中流行。
大家也一直希望Java实现闭包。Java是通过内部类实现的，但是实现的不完整。
先看现象。我们在上面的HandlerTest程序的主体部分增加一个自由变量，代码如下：

        int i = 0;
        test.handleEvent(new IMessenger() {
            public void sendMessage(String msg) {
                System.out.println("event handled. " + msg);
                int j=0;
                j = i+j;
            }
        });

在JDK7之前，会有编译错误：Local variable i defined in an enclosing scope must be final。这个错误出现在j=i+j;这一行。必须让外面的这个自由变量i定义成final。（JDK8之后不会出错。但是实际上还是有这个限制，你试着把上面的代码修改一下，给i进行一个赋值就会看出来了。）
把i定义成final之后，意味着我们在匿名类中不能给自由变量i赋值了。
这儿在类里面定义了内部类，而内部类又引用了外部的自由变量，这就构成了典型的闭包。Java并没有完全实现闭包，在生成匿名类的时候，它把外部自由变量i的value传入，实际上是一个拷贝，因此内部其实不能修改外部的自由变量了。Java团队此处又偷了一个懒，干脆就规定外部的这个自由变量为final。
我们可以反编译这个类，看看编译器处理之后的代码，为：

      public void sendMessage(String msg) {
        System.out.println("event handled. " + msg);
        int j = 0;
        j = this.val$i + j;
      }

注意编译器把j=i+j;变成了j = this.val$i + j;，只是一个外部i的拷贝。
对于普通的内部类，为什么又不用呢？因为普通的内部类有构造函数，在构造函数过程中把外部类传进来。但是匿名内部类是没有构造函数的。
Java这样处理，引起了多年的争论。我个人还是比较赞同Java团队的做法的，这样虽然限制很多，但是代码安全，并且预留了以后完全支持闭包的可能性。
以后我会有专题讲解闭包，这次讲解只是就着匿名内部类带一下。你们看到了，Inner Classs起步于一个简单的模型，基本内容很简单，但是一步步深入，就会牵扯出高级的话题。这就有点像推倒多米诺骨牌，第一下只是很小的一个动作，后面却又大动作等着。很多技术都是这样的，越研讨越深，不断发现新挑战，这也是一种乐趣。
正如我们探索未知的山川，层峦叠嶂，接应不暇，这山望见那山高，前路永远有精彩的风景。也正如我们进入桃园洞口，刚开头武陵人只是缘溪捕鱼，到了半道，忽逢桃花林，复前行，林尽水源却得一山，从口入，行数十步，豁然开朗，得此桃源仙境。
学问上这种探索的乐趣，王国维先生曾言：众里寻他千百度，慕然回首，那人却在，灯火阑珊处。
咦！微斯人，吾谁与归！