今天来看看另一个更加神奇的类——匿名内部类。
就像它的名字表示的那样，这个类是匿名的，用完之后，深藏功与名，就像扫地僧那样默默潜藏于深山之中。匿名内部类不仅没有名字，连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关键字来修饰需要使用的变量。
至此，匿名内部类讲解完毕，欢迎大家继续关注！
真正重要的东西，用眼睛是看不见的。