Java 匿名内部类

上一篇：Java 内部类

下面这个这个例子看起来会很奇怪，contents() 方法将返回值的生成与表示这个返回值的类的定义结合在一起。但是这个类是匿名的，这个类没有名字。看似你在这里要创建一个Contents 对象，但是你却在这里插入了一个类的定义。这种语法指的是：“创建一个继承自Contents 的匿名的类的对象”，contents() 方法返回的引用会被向上转型为Contents的引用。

public class Parcel {
    public Contents contents(){
        return new Contents() {
            private int num = 10;
            @Override
            public int value() {
                return num;
            }
        };
    }
    public static void main(String[] args) {

        Parcel parcel = new Parcel();
        Contents contents = parcel.contents();

        System.out.println(contents.value());
    }
}

interface Contents{
    int value();
}

输出
10

    在匿名内部类的末尾的分号 ，并不是用来标记此内部类结束的。它标记的是表达式的结束，只不过这个表达式正巧包含了匿名内部类罢了。

如果定义了一个匿名内部类，并希望它使用一个在其外部定义的对象(该对象是通过外围方法传递进来的)，那么编译器会要求你只能使用该对象的引用最初始时的状态，即当你调用外部定义的对象的时候你不允许以任何形式去修改或重新定义它们 [在jdk1.8之前要求的是传入的参数必须是final 的,在jdk1.8 之后即使你不将参数定义为final 也是可以的]，如果你违反了这条规定那么你将会得到一个编译时期的错误提醒。通过下面的程序我们可以看出：我们在匿名内部类试图修改i 的值，但是却报了一个错误，告诉我们i 需要是final 的，我们在匿名内部类也修改了外部类的num 这是可以的，并且在内部类修改后，外部类的num 值也发生了变化。

public class Parcel {
    private int num = 1;

    public void printNum(){
        System.out.println("num = " +num);
    }
    public Contents contents(int i){
        return new Contents() {
            @Override
            public void print() {
                // i = 100; Variable 'i' is accessed from within inner class,
                // needs to be final or effectively final
                num = 10;
                System.out.println("i = " + i +",num = " + num);
            }
        };
    }
    public static void main(String[] args) {

        Parcel parcel = new Parcel();
        Contents contents = parcel.contents(100);

        parcel.printNum();
        contents.print();
        parcel.printNum();
    }
}

interface Contents{
    void print();
}

输出
num = 1
i = 100,num = 10
num = 10

有的时候你想要在匿名内部类做类似构造器的行为应该怎么做呢？在匿名类中不可能会有命名的构造器，因为这个类根本没有名字。如果我们想要完成这样的功能，我们可以通过实例初始化的方式，就能为匿名内部类达到创建构造器的效果。就像下面这样：

public class Parcel {
    public Contents contents(int i){
        return new Contents(i) {
            @Override
            public void f() {
                System.out.println("f() run .......");
            }
        };
    }
    public static void main(String[] args) {

        Parcel parcel = new Parcel();
        Contents contents = parcel.contents(100);

        contents.f();
    }
}

abstract class Contents{        //注意这里不可以是接口，接口没有构造函数
    Contents(int i ){
        System.out.println("Constructor run ......" + i);
    }
    public abstract void f();
}

输出
Constructor run ……100
f() run …….

匿名内部类与正规的继承相比比较受限，因为匿名匿名内部类既可以扩展类，也可以实现接口，但是两者不能兼备，如果想要实现接口那也只可以实现一个接口。匿名内部类在有些时候为我们提供了很大的方便：有时候我们只是想创建一个简单的线程但是又不想大费周折创建一个类去实现Runnable 接口，这时我们使用匿名内部类就会使代码变得简单许多。

public class ThreadTest {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 10; i++){
                    System.out.print(i + " ");
                }
            }
        }).start();
    }
}

下一篇：Java 闭包与回调

                                                                                                            参考书籍：
                                                                                                                《Java 编程思想》Bruce Eckel 著 陈昊鹏 译