Java语法糖系列五：内部类和闭包

目录：
Java语法糖系列一：可变长度参数和foreach循环
http://www.jianshu.com/p/628568f94ef8

Java语法糖系列二：自动装箱/拆箱和条件编译
http://www.jianshu.com/p/946b3c4a5db6

Java语法糖系列三：泛型与类型擦除
http://www.jianshu.com/p/4de08deb6ba4

Java语法糖系列四：枚举类型
http://www.jianshu.com/p/ae09363fe734

Java语法糖系列五：内部类和闭包
http://www.jianshu.com/p/f55b11a4cec2

---

内部类

Java的内部类也是一个语法糖，它仅仅是一个编译时的概念，outer.java里面定义了一个内部类inner，一旦编译成功，就会生成两个完全不同的.class文件了，分别是outer.class和outer$inner.class。所以内部类的名字完全可以和它的外部类名字相同。

内部类分为四种：成员内部类、局部内部类、匿名内部类、静态内部类。但本篇不是谈论四种内部类的用法的，只讲内部类一些值得注意的地方。

为什么要使用内部类

在《Think in java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

因为Java不支持多继承，支持实现多个接口。但有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

成员内部类

成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。在成员内部类中要注意两点

• 成员内部类中不能存在任何static的变量和方法；

• 成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。例子略。

局部内部类和匿名内部类

局部内部类是嵌套在方法和作用域内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

而匿名内部类也可以说是局部内部类的一种，有时候一个类只使用一次，就可以用匿名内部类，告诉GC只用一次就可以回收了，同时也可以简化代码和方便地定义回调

需要注意的是局部内部类和匿名内部类引用外部变量时，外部的变量需要是final 的：

abstract class InnerClass {
public abstract void print();
}
public class Outer {
public  void test1(final String s1) {// 参数必须是final
    //成员内部类
    InnerClass c = new InnerClass() {
        public void print() {
            System.out.println(s1);
        }
    };
    c.print();
}

public  void test2(final String s2) {// 参数必须是final
    //匿名内部类
     new Outer() { //名字可以跟外部类一样
        public void print() {
            System.out.println(s2);
        }
    }.print();
}    
public static void main(String[] args) {
    Outer o=new Outer();
    o.test1("inner1");
    o.test2("inner2");

}
}

为什么匿名内部类和局部内部类引用外部的变量必要是final的呢？
直接看编译出来的源码吧

InnerClass:

    abstract class InnerClass
    {
      public abstract void print();
    }

Outer.class:

`import java.io.PrintStream;

public class Outer
{
  public void test1(String paramString)
  {
Outer.1 local1 = new InnerClass(this, paramString) {
  public void print() {
    System.out.println(this.val$s1);//引用了s1变量
  }

};
local1.print(); }

  public void test2(String paramString) {
new Outer(this, paramString) {//名字可以一样
  public void print() {
    System.out.println(this.val$s2);
  }
}
.print();
  }

 public static void main(String[] paramArrayOfString)
  {
Outer localOuter = new Outer();
localOuter.test1("inner1");
localOuter.test2("inner2");
  }
}

局部内部类Outer$1.class:

import java.io.PrintStream;
class 1 extends InnerClass
{
  public void print()
  {
    System.out.println(this.val$s1);//引用了s1变量
  }
}

匿名内部类Outer$2.class:

import java.io.PrintStream;
class 2 extends Outer
{
  public void print()
  {
    System.out.println(this.val$s2);//引用了s2变量
  }
}

看源码两个内部类各编译出了一个独立的class文件，也就是说Outer$1和Outer$2的生命周期是对象级别的，而变量s1、s2是方法级别的，方法运行完了变量就销毁了，而局部内部类对象Outer$1和Outer$2还可能一直存在(只能没有人再引用该对象时,它才会被GC回收),它不会随着方法运行结束就马上死亡。这时可能会出现了一种"荒唐"的结果:局部内部类对象inner_object要访问一个已不存在的局部变量s1、s2!

也有人说：当方法调用完了，内部类也不可能再被访问到了，照理内部类对象也应该成为了垃圾。
别忘了Java还有反射，而且在多线程的情况下完全有可能主线程的方法运行结束，而内部类还在运行,例如：

public void execute() {
  final int s = 10;
       class InnerClass {
          public void execute() {
              new Thread() {
              @Override
               public void run() {
                 try {
                        Thread.currentThread().sleep(2000);
                        System.out.println(s);
                 } catch (final InterruptedException e) {
                       e.printStackTrace();
                  }
               }
             }.start();
           }
         }
        new InnerClass().execute();
        System.out.println("主方法已经over");
    } 

为什么把变量定义为final就能避免上述问题？
看stackoverflow上的一个讨论
http://stackoverflow.com/questions/3910324/why-java-inner-classes-require-final-outer-instance-variables

stackoverflow里最高票的答案说到，当主方法结束时，局部变量会被cleaned up 而内部类可能还在运行。当局部变量声明为final时，当使用已被cleaned up的局部变量时会把局部变量替换成常量：

The compiler can then just replace the use of lastPrice and price in the anonymous class with the values of the constants (at compile time, ofcourse)

也就是说当变量是final时,编译器会将final局部变量"复制"一份,复制品直接作为局部内部中的数据成员.这样，当局部内部类访问局部变量时,其实真正访问的是这个局部变量的"复制品"。因此:当运行栈中的真正的局部变量死亡时,局部内部类对象仍可以访问局部变量(其实访问的是"复制品")。而且，由于被final修饰的变量赋值后不能再修改，所以就保证了复制品与原始变量的一致。给人的感觉:好像是局部变量的"生命期"延长了。
这就是java的闭包。

最后贴两段关于闭包的笔记，来源于网络：

闭包是个什么东西呢？
Ruby之父松本行弘在《代码的未来》一书中解释的最好：闭包就是把函数以及变量包起来，使得变量的生存周期延长。闭包跟面向对象是一棵树上的两条枝，实现的功能是等价的。

Java中闭包带来的问题
　　在Java的经典著作《Effective Java》、《Java Concurrency in Practice》里，都提到：匿名函数里的变量引用，也叫做变量引用泄露，会导致线程安全问题，因此在Java8之前，如果在匿名类内部引用函数局部变量，必须将其声明为final，即不可变对象。(Python和Javascript从一开始就是为单线程而生的语言，一般也不会考虑这样的问题，所以它的外部变量是可以任意修改的)。
　　而java8的lambda 表达式之所以不用写final，是因为Java8这里加了一个语法糖：在lambda表达式以及匿名类内部，如果引用某局部变量，则直接将其视为final。本质并没有改变。

静态内部类

略。