内部类
内部类是一种较为特殊的类形式，定义在另一个类中的类，叫做内部类，是主类的一部分，可以把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。
作用
- 内部类方法可以访问该类定义所在的作用域中的数据，包括私有数据
- 内部类可以对同一个包中的其他类隐藏起来
内部类分为
成员内部类
成员内部类可以等同的看做是成员变量，可以有权限修饰符，内部不能有静态声明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class Outter {
class Inner {
public void print(String s) {
System.out.println(s);
}
}
public Inner buildInner() {
return new Inner();
}
public static void main(String[] args) {
Outter outter = new Outter();
Inner inner = outter.buildInner();
inner.print("输出");
}
}
|
成员内部类与外部类联系
成员内部类可以使用外部类的所有成员，而且不需要任何特殊条件，且拥有其对于外部类所有元素的访问权。
在创建成员内部类对象时，它会与创建它的外围对象有某种联系隐式引用(内部类对象会秘密的捕获一个指向外部类的引用，通过这个引用可以用来访问外部类的成员)，通过这个隐式引用可以访问外部类的所有成员
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
| public class Sequence {
private Object[] items;
private int next;
public Sequence(int size) {
items = new Object[size];
}
public void add(Object obj) {
if (next < items.length) {
items[next] = obj;
next++;
}
}
public SequenceSelector selector() {
return new SequenceSelector();
}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for (int i = 0; i < 10; i++) {
sequence.add(i);
}
SequenceSelector selector = sequence.selector();
while (!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
private class SequenceSelector {
private int current = 0;
public boolean end() {
return current == size();
}
public int size() {
return items.length;
}
public Object current() {
return items[current];
}
public void previous() {
if (current > 0) {
current--;
}
}
public void next() {
if (current < items.length) {
current++;
}
}
}
}
|
使用.this和.new
在成员内部类如何生成外部类对象的引用，使用外部类名.this
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class DoThis {
class Inner{
public DoThis outer(){
return DoThis.this;
}
}
public void f(){
System.out.println("DoThis.f()");
}
public Inner inner(){
return new Inner();
}
public static void main(String[] args) {
DoThis doThis = new DoThis();
Inner inner = doThis.inner();
inner.outer().f();
}
}
|
外部类如何创建成员内部类的对象，需要使用外部类实例.new
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class DoNew {
class Inner {
public void f(){
System.out.println("Inner.f()");
}
}
public static void main(String[] args) {
DoNew doNew = new DoNew();
Inner inner = doNew.new Inner();
inner.f();
}
}
|
在拥有外部类对象之前是不可能创建成员内部类对象的，成员内部类对象会连接到创建它的外部类对象上，静态内部类不需要外部类对象的引用。
对于私有的成员内部类，外部类是可以访问到它的，其他的类无法访问到，如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class DoNew {
private class Inner {
public void f(){
System.out.println("Inner.f()");
}
}
public static void main(String[] args) {
DoNew doNew = new DoNew();
Inner inner = doNew.new Inner();
inner.f();
}
}
public class Test {
public static void main(String[] args) {
DoNew doNew = new DoNew();
}
}
|
成员内部类深度剖析
上面提到在拥有外部类对象之前是不可能创建成员内部类对象的，成员内部类对象会连接到创建它的外部类对象上，这里来说明一下为什么
来看一下这个Sequence.SequenceSelector类的构造器是什么
javap -c Sequence.SequenceSelector
1
2
3
4
5
6
7
| com.zhanghe.study.inner.Sequence$SequenceSelector(com.zhanghe.study.inner.Sequence, com.zhanghe.study.inner.Sequence$1);
Code:
0: aload_0
1: aload_1
2: invokespecial #1
5: return
|
发现这个Sequence.SequenceSelector类构造器默认并不是无参构造器，而是要传外部类对象的
局部内部类
在方法作用域内创建的类，称为局部内部类，局部内部类没有访问修饰符，可以等同的看做是局部变量，局部内部类在访问局部变量时，局部变量必须使用final修饰*
1
| Variable 'name' is accessed from within inner class, needs to be final or effectively final
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class MethodOuter {
public Destination desc(String s){
class Inner implements Destination{
@Override
public void f(){
System.out.println("Inner.f()传入参数"+s);
}
}
return new Inner();
}
public static void main(String[] args) {
MethodOuter methodOuter = new MethodOuter();
methodOuter.desc("test").f();
}
}
|
Inner是desc()方法的一部分，在方法之外访问不到
匿名内部类
匿名内部类，就是没有定义类名的一种嵌套类
如一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public interface Contents {
void f();
}
public class Outer1 {
public Contents contents(){
return new Contents(){
@Override
public void f() {
System.out.println("Contents匿名内部类.f()");
}
};
}
public static void main(String[] args) {
Outer1 outer1 = new Outer1();
outer1.contents().f();
}
}
|
静态内部类
静态内部类可以等同的看做是静态变量，可以有权限修饰符
静态内部类，内部类对象与外部类对象之间没有联系，将内部类声明为static，普通的内部类对象隐式的保存了一个引用，指向创建它的外部类对象，当内部类是static的时候，意味着
在创建静态内部类时不需要将静态内部类的实例绑定在外部类实例上。
接口内部类
静态内部类可以作为接口的一部分，放到接口中任何类都是public static的