概述
在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致
内部类可以分为四种：静态内部类、成员内部类、局部内部类和匿名内部类
优点
- 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据
- 内部类不为同一包的其他类所见，具有很好的封装性
- 内部类有效实现了“多重继承”，优化 java 单继承的缺陷
- 匿名内部类可以很方便的定义回调
应用场景
一些多算法场合
解决一些非面向对象的语句块
适当使用内部类，使得代码更加灵活和富有扩展性
当某个类除了它的外部类，不再被其他的类使用时
实现
静态内部类
概念
定义在类内部的静态类，就是静态内部类
静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量，静态内部类的创建方式：new 外部类.静态内部类()
代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Outer {
private static final int A = 1;
static class StaticInner {
public void test() {
System.out.println(A);
}
}
public static void main(String[] args) {
Outer.StaticInner inner = new Outer.StaticInner();
inner.test();
}
}
|
成员内部类
概念
定义在类内部，成员位置上的非静态类，就是成员内部类
成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式：外部类实例.new 内部类()
代码实现
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
|
public class Outer {
int a = 1;
private static final int B = 2;
class Inner {
public void test() {
System.out.println(a);
System.out.println(B);
}
}
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.test();
}
}
|
局部内部类
概念
定义在方法中的内部类，就是局部内部类
定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法，局部内部类的创建方式：在对应方法内，new 内部类()
代码实现
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
|
public class Outer {
int out_a = 1;
private static final int STATIC_B = 2;
public void test() {
int inner_c = 3;
class Inner {
void fun() {
System.out.println(out_a);
System.out.println(STATIC_B);
System.out.println(inner_c);
}
}
Inner inner = new Inner();
inner.fun();
}
public static void main(String[] args) {
Outer outer = new Outer();
outer.test();
}
}
|
匿名内部类
概念
匿名内部类就是没有名字的内部类，日常开发中使用的比较多
除了没有名字，匿名内部类还有以下特点：
- 匿名内部类必须继承一个抽象类或者实现一个接口
- 匿名内部类不能定义任何静态成员和静态方法
- 当所在的方法的形参需要被匿名内部类使用时，必须声明为 final
- 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法
代码实现
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
|
public class Outer {
public static void main(String[] args) {
new Service() {
@Override
public void method() {
System.out.println("匿名内部类测试1");
}
}.method();
Service service = new Service() {
@Override
public void method() {
System.out.println("匿名内部类测试2");
}
};
service.method();
}
}
interface Service {
void method();
}
|
