JAVA匿名内部类

一、内部类的定义

内部类（nested classes），面向对象程序设计中，可以在一个类的内部定义另一个类。嵌套类分为两种，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

　　内部类是JAVA语言的主要附加部分。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：

　　　　其一、在一个类（外部类）中直接定义的内部类；
　　　　其二、在一个方法（外部类的方法）中定义的内部类;
　　　　其三、匿名内部类。
　　　　

　　为什么需要内部类？

　　　　⒈ 内部类对象可以访问创建它的对象的实现，包括私有数据；
　　　　⒉ 内部类不为同一包的其他类所见，具有很好的封装性；
　　　　⒊ 使用内部类可以很方便的编写事件驱动程序；
　　　　⒋ 匿名内部类可以方便的定义运行时回调；
　　　　5.内部类可以方便的定义
　　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

二、内部类分类

1.成员内部类

2.方法内部类

3.匿名内部类

三、匿名内部类的使用

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：

new 父类构造器（参数列表）|实现接口（）      {       //匿名内部类的类体部分      }

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

public abstract class Bird {    private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public abstract int fly();}public class Test {    public void test(Bird bird){        System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");    }    public static void main(String[] args) {        Test test = new Test();        test.test(new Bird() {            public int fly() {                return 10000;            }            public String getName() {                return "大雁";            }        });    }}------------------Output：大雁能够飞 10000米

在Test类中，test()方法接受一个Bird类型的参数，同时我们知道一个抽象类是没有办法直接new的，我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。
由于匿名内部类不能是抽象类，所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。
对于这段匿名内部类代码其实是可以拆分为如下形式：

public class WildGoose extends Bird{    public int fly() {        return 10000;    }    public String getName() {        return "大雁";    }}WildGoose wildGoose = new WildGoose();test.test(wildGoose);

在这里系统会创建一个继承自Bird类的匿名类的对象，该对象转型为对Bird类型的引用。
对于匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用。对于上面的实例，如果我们需要对test()方法里面内部类进行多次使用，建议重新定义类，而不是使用匿名内部类。

四、注意事项

1.不使用匿名内部类来实现抽象方法

abstract class Person {    public abstract void eat();}class Child extends Person {    public void eat() {        System.out.println("eat something");    }}public class Demo {    public static void main(String[] args) {        Person p = new Child();        p.eat();    }}

运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用
但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类

2.在接口上使用匿名内部类

interface Person {    public void eat();}public class Demo {    public static void main(String[] args) {        Person p = new Person() {            public void eat() {                System.out.println("eat something");            }        };        p.eat();    }}

运行结果：eat something

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

3.Thread类的匿名内部类实现

public class Demo {    public static void main(String[] args) {        Thread t = new Thread() {            public void run() {                for (int i = 1; i <= 5; i++) {                    System.out.print(i + " ");                }            }        };        t.start();    }}

运行结果：1 2 3 4 5

4.Runnable接口的匿名内部类实现

public class Demo {    public static void main(String[] args) {        Runnable r = new Runnable() {            public void run() {                for (int i = 1; i <= 5; i++) {                    System.out.print(i + " ");                }            }        };        Thread t = new Thread(r);        t.start();    }}

运行结果：1 2 3 4 5