匿名内部类
匿名内部类，就是没有名字的一种嵌套类。它是Java对类的定义方式之
为什么要使用匿名内部类
在实际开发中，我们常常遇到这样的情况：一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余。
匿名内部类是局部内部类的一种简化形式.本质上是一个对象,是实现了该接口或继承了该抽象类的子类对象.
下面详细说明一下
假设当前有一个接口，接口中只有一个方法
1
2
3
| public interface Interface01 {
void show();
}
|
为了使用该接口的show方法，我们需要去创建一个实现类，同时书写show方法的具体实现方式
1
2
3
4
5
6
| public class Interface01Impl implements Interface01{
@Override
public void show() {
System.out.println("I'm a impl class...");
}
}
|
如果实现类Interface01Impl全程只使用一次，那么为了这一次的使用去创建一个类，未免太过麻烦。我们需要一个方式来帮助我们摆脱这个困境。匿名内部类则可以很好的解决这个问题。
我们使用匿名内部类
1
2
3
4
5
6
7
8
9
10
| public static void main(String[] args) {
Interface01 interface01 = new Interface01() {
@Override
public void show() {
System.out.println("这里使用了匿名内部类");
}
};
interface01.show();
}
|
给匿名内部类名命:
虽然这是匿名内部类,但是仍然可以利用多态来给匿名内部类名命
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| public class MyTest {
public static void main(String[] args) {
new AA() {
@Override
public void aa() {
System.out.println("aaaaaaaaaaaaaaaa");
}
@Override
public void hehe() {
System.out.println("hehehehehehhehehhe");
}
};
AA aa = new AA() {
@Override
public void aa() {
System.out.println("aaaaaaaaaaaaaa744444aa");
}
@Override
public void hehe() {
System.out.println("hehehehehe888877777hhehehhe");
}
};
aa.aa();
aa.hehe();
}
}
abstract class AA {
public abstract void aa();
public abstract void hehe();
}
|
匿名内部类的好处:
匿名内部类，经常作为参数，或返回值，使用比较方便
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public class MyTest {
public static void main(String[] args) {
test(new WW() {
@Override
public void hehe() {
System.out.println("111111111");
}
});
}
public static void test(WW ww) {
ww.hehe();
}
}
abstract class WW {
public abstract void hehe();
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| public class MyTest {
public static void main(String[] args) {
BB bb = getBB();
bb.bb();
}
public static BB getBB2() {
BB b2 = new BB() {
@Override
public void bb() {
System.out.println("bbbbbbbbbbbbbbbbb222222222");
}
};
return b2;
}
}
abstract class BB {
public abstract void bb();
}
|
一个类中可以嵌套一个接口:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class MyTest2 {
public static void main(String[] args) {
new Inter() {
public void show() {
System.out.println(this.a);
System.out.println(Inter.a);
}
}.show();
}
}
interface Inter {
public static final int a = 23;
}
|
参考资料：
匿名内部类
什么是匿名内部类，如何使用匿名内部类