今天来看看另一个更加神奇的类——匿名内部类。
就像它的名字表示的那样，这个类是匿名的，用完之后，深藏功与名，就像扫地僧那样默默潜藏于深山之中。匿名内部类不仅没有名字，连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关键字来修饰需要使用的变量。
至此，匿名内部类讲解完毕，欢迎大家继续关注！
---------------------
作者：弗兰克的猫__
来源：CSDN
原文：https://blog.csdn.net/MFrank2018/article/details/80313976
版权声明：本文为博主原创文章，转载请附上博文链接！