【Java入门提高篇】Day8 Java内部类——匿名内部类

　　今天来看看另一个更加神奇的类——匿名内部类。

　　就像它的名字表示的那样，这个类是匿名的，用完之后，深藏功与名，就像扫地僧那样默默潜藏于深山之中。匿名内部类不仅没有名字，连class关键字都省掉了，而且匿名内部类必须继承于某个类或者实现某个接口，长的就像这样：

new 父类（参数列表）|实现接口（） {    
         //匿名内部类的内部定义
        }  

　　来看一个栗子：

public abstract class Human {
    public abstract void walk();
}

　　这是一个抽象类，如果使用匿名内部类来继承的话是这样的：

public class AnonymousTest {
    public static void main(String[] args) {
        Human human = new Human(){
            public void walk(){
                System.out.println("AnonymousHuman can walk.");
            };
        };
        human.walk();
    }
}

　　简单粗暴，看起来就像局部内部类的简化版。如果不使用匿名内部类，会是怎样呢？

　　我们需要先创建一个类来继承这抽象类：

public class Man extends Human {
    @Override
    public void walk() {
        System.out.println("Man can walk.");
    }
}

　　然后再来使用这个类：

public class AnonymousTest {
    public static void main(String[] args) {
        Human human = new Man();
        human.walk();
    }
}

　　因为一个单独的类往往放在一个单独的文件中，如果这个类只需要创建一个对象，那未免有些大材小用了，从上面的栗子可以比较出匿名内部类的一个优势：在类只需要创建一个对象的情况下更加简单方便。

　　再举一个实际一点的栗子：

public class AnonymousTest {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(i);
                }
            }
        };
        t.start();
    }
}

　　这里创建了一个继承于Thread的匿名内部类，覆盖了其中的 run方法，并创建了一个实例返回给了t，然后再调用run方法，可以看到，匿名内部类只能存在一个实例对象，因为new过一次就无法再创建了，也许会觉得局部内部类已经很局限了，为什么要出现比局部内部类适用范围更小的匿名内部类？、

　　这你就不懂了吧，在Java的实际使用中，匿名内部类大有用处，为什么要使用匿名内部类呢？

　　有时候，我们创建的类只需要一个实例，比如说在多线程中，要使用多线程，一般先继承Thread类或者实现Runnable接口，然后再去调用它的方法，而每个任务一般都不一样，每次都新建一个类显然会很难管理，因为每个类只用一次就丢掉了，这个时候使用匿名内部类就很方便了，不仅不需要管理一堆一次性类，而且创建起来简单粗暴。就像上述栗子，还能简化成这样：

public class AnonymousTest {
    public static void main(String[] args) {
        new Thread() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(i);
                }
            }
        }.start();
    }
}

　　创建实例后直接调用run方法，简单粗暴。

　　匿名内部类不仅可以继承于类，也可以实现于接口，比如说这样：

public class AnonymousTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(i);
                }
            }
        }).start();
    }
}

 　　当然，还有些不得不用内部类的情况，类只能继承于一个类，如果一个类需要使用到另一个包中的另一个类的一个protected方法，却已经继承于另一个类，那么这个时候就不得不用内部类来解决了。

　　比如说，还有一个Woman（女人）类：

public class Woman {
    protected void dance(){
        System.out.println("Woman can dance.");
    }
}

　　这个时候，如果Man（男人）也难不住寂寞，想要dance（跳舞）一下，那该怎么办呢？继承Woman类？显然不合乎逻辑，而且也无法实现，因为已经继承于Human类了，但就是想要dance，该怎么办？

　　内部类的出现让这个问题变得很简单：

public class Man extends Human {
    @Override
    public void walk() {
        System.out.println("Man can walk.");
    }

    public void dance(){
        new Woman(){
            public void manDance(){
                super.dance();
            }
        }.manDance();
    }
}

　　因为在不同的包下，不能直接使用Woman的dance方法，但是可以用内部类来继承，从而调用protected方法，然后再放入Man的方法中，这样，Man也能像Woman一样dance了：

public class AnonymousTest {
    public static void main(String[] args) {
        Man human = new Man();
        human.walk();
        human.dance();
    }
}

　　当然，使用匿名内部类还是有很多限制的：

　　1、匿名内部类必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

       2、匿名内部类不能定义构造函数。

       3、匿名内部类中不能存在任何的静态成员变量和静态方法。

       4、匿名内部类是特殊的局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

       5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

　　那么问题来了，怎样初始化一个匿名内部类呢？毕竟匿名内部类是不能有构造器的。

　　当然，首先，还是可以使用初始化块来实现的，就像这样：

public class AnonymousTest {
    public static void main(String[] args) {
        Human human = new Human() {
            private String name;
            {
                name = "human";
            }
            @Override
            public void walk() {
                System.out.println(name + " walk.");
            }
        };
        human.walk();
    }
}

　　但是这样显然就比较呆板，不够灵活，无法接受外部参数，那么怎样灵活使用呢？不要心急，方法总比问题多，还是有办法解决的：

public class AnonymousTest {
    public static void main(String[] args) {
        Human human = new AnonymousTest().getHumanInstance("Frank");
        human.walk();
    }

    public Human getHumanInstance(final String name){
        return new Human() {
            private String nameA;
            {
                nameA = name;
            }
            @Override
            public void walk() {
                System.out.println(nameA + " walk.");
            }
        };
    }
}

　　这里利用初始化块来对匿名内部类进行初始化，注意，如果匿名内部类需要使用外部的参数或者变量，那么必须使用final修饰，因为内部类使用的其实是参数的拷贝，并不是参数本身，为了更明显的表明参数不可变，编译器会要求使用final关键字来修饰需要使用的变量。

　　至此，匿名内部类讲解完毕，欢迎大家继续关注！