释放双眼，带上耳机，听听看~！
内部类，inner class，是定义在另一个类中的类。内部类是一种编译器现象，与虚拟机无关，编译器将会把内部类翻译成用$分隔外部类名与内部类名的常规类文件，而虚拟机对此一无所知。内部类比常规类更加强大，最大的特点是内部类可以访问外围类的私有数据。
非内部类的修饰符 only public, abstract & final are permitted，而内部类可以有private修饰。
内部类有三点原因被需要：
- 内部类可以访问该类定义所在的作用域中的数据，包括private类型的。
- 内部类可以对同一个包中的其他类隐藏起来。
- 当想要定义一个回调函数且不想编写大量代码的时候，使用匿名内部类比较便捷。
内部类的一般写法
下面的演示程序演示了使用内部类访问外部类的私有数据。
其中内部类Pair访问了外部类OuterClass的私有数据secret。最终在console输出100。
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
2
3public class Test{
4 public static void main(String...arg){
5 OuterClass outerClass = new OuterClass();
6 outerClass.setSecret(100);
7 System.out.println(outerClass.getInfo());
8 }
9}
10
11class OuterClass{
12 private int secret;
13
14 public int getInfo(){
15 Pair pair = new Pair();
16 return pair.getSecret();
17 }
18
19 public void setSecret(int secret){
20 this.secret = secret;
21 }
22
23 public class Pair{
24 public Pair(){
25 this.take = secret;
26 }
27
28 public int getSecret(){
29 return this.take;
30 }
31
32 private int take;
33 }
34}
35
36
下面是编译完成之后的类文件：
可见，内部类生成了名为OuterClass$Pair.class的文件。
为了能运行上面这个程序，内部类总有一个隐式引用，它指向了创建它的外部类对象。下面，我们将这个外部类对象显示表示出来，暂且称之为outer对象。外部类的引用在内部类的构造器中设置。下面的程序和上面的功能完全一样，最终在控制台输出100。
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
2
3public class Test{
4 public static void main(String...arg){
5 OuterClass outerClass = new OuterClass();
6 outerClass.setSecret(100);
7 System.out.println(outerClass.getInfo());
8 }
9}
10
11class OuterClass{
12 private int secret;
13
14 public int getInfo(){
15 Pair pair = this.new Pair(this);
16 return pair.getSecret();
17 }
18
19 public void setSecret(int secret){
20 this.secret = secret;
21 }
22
23 public class Pair{
24 public Pair(OuterClass outerClass){
25 OuterClass outer = outerClass;
26 this.take = outer.secret;
27 }
28
29 public int getSecret(){
30 return this.take;
31 }
32
33 private int take;
34 }
35}
36
37
局部内部类
在一个方法中定义的局部类，即局部内部类。它的作用与被限定在声明这个的块中。
局部内部类可以对外界完全的隐藏起来，除了定义局部类的方法，没有其他任何方法知道局部类的存在。
比如把上面程序中OuterClass的方法getInfo修改成下面这样：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2 class Pair{//修饰语 only abstract or final is permitted
3 public Pair(){
4 this.take = secret;
5 }
6
7 public int getSecret(){
8 return this.take;
9 }
10
11 private int take;
12 }
13 Pair pair = new Pair();
14 return pair.getSecret();
15 }
16
匿名内部类
假如只创建了这个类的一个对象，就不必命名了。这种类被称为匿名类。
由于匿名内部类没有名字，而构造器的名字必须和类名一致，所以匿名内部类没有构造器。
匿名内部类是
要扩展或实现父类或接口，所以只能是
- 继承一个类，重写方法
- 实现一个接口
下面的程序在外部类OuterClass中的getinfo方法中定义了一个实现了Pair接口的匿名内部类，并且调用其getSecret方法，返回一个int类型的值。
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
2
3public class Test{
4 public static void main(String...arg){
5 OuterClass outerClass = new OuterClass();
6 outerClass.setSecret(100);
7 System.out.println(outerClass.getInfo());
8 }
9}
10
11class OuterClass{
12 private int secret;
13
14 public void setSecret(int secret){
15 this.secret = secret;
16 }
17
18 public int getInfo(){
19 return new Pair(){
20 public int getSecret(){
21 return secret;
22 }
23 private int take;
24 }.getSecret();
25 }
26}
27
28interface Pair{
29 public int getSecret();
30}
31
静态内部类
把一个类隐藏在另一个类的内部，内部类不可引用外部类对象，取消了产生的引用。
编译器会自动给内部类加上一个
reference，指向产生它的那个外部类的对象，如果不想要或者说不需要这个
reference，那么我们就可以把这个内部类声明为
static，禁止这个
reference的产生。
如下例子，OuterClass.StaticInnerClass直接就是一个类，别的类可以调用，而OuterClass.InnerClass根本不是一个可以用new OuterClass.InnerClass()初始化的类。
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
2
3public class Test{
4 public static void main(String...arg){
5 OuterClass p = new OuterClass();
6 p.fo();//com.xujin.OuterClass
7 OuterClass.StaticInnerClass i = new OuterClass.StaticInnerClass(p);
8 i.shuchu("world!");//Hello,world!
9 i.getClassName();//com.xujin.OuterClass$InnerClass
10
11 //OuterClass.InnerClass ic = new OuterClass.InnerClass();//error,这里OuterClass.InnerClass不是一个类型type，类比静态域和非静态域
12 p.new InnerClass().getClassName();//com.xujin.OuterClass$InnerClass
13 }
14}
15
16class OuterClass{
17 static class StaticInnerClass{
18 StaticInnerClass(OuterClass outerClass){
19 outer = outerClass;
20 }
21
22 public void shuchu(String name){
23
24 System.out.println("Hello," + name);
25 }
26
27 public void getClassName(){
28 System.out.println(this.getClass().getName());
29 }
30
31 private OuterClass outer;
32 }
33
34 class InnerClass{
35 public void getClassName(){
36 System.out.println(this.getClass().getName());
37 }
38 }
39
40 public void fo(){
41 System.out.println(this.getClass().getName());
42 }
43
44 private int OuterPar;
45}
46
47
下面这个例子单独把静态内部和非静态内部类的创建规则搞了个一通，方便以后查看。
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
2
3//称Test类为其他类
4public class Test{
5 public static void main(String...arg){
6
7 //在其他类中创建一个静态内部类
8 //StaticInnerClass aStaticInnerClass = new StaticInnerClass();//必须加OuterClass
9 OuterClass.StaticInnerClass aStaticInnerClass = new OuterClass.StaticInnerClass();
10 //OuterClass.StaticInnerClass bStaticInnerClass = new OuterClass().new StaticInnerClass();//不能用外部类的实例创建静态内部类
11
12 //在其他类中创建一个非静态内部类
13 //OuterClass.InnerClass aInnerClass = new OuterClass.InnerClass();//错误，必须用一个外部类的实例new一个非静态内部类
14 OuterClass.InnerClass aInnerClass = new OuterClass().new InnerClass();
15
16
17 }
18
19 //其他类的静态函数和非静态函数创建内部类的方法一致
20 public void amethod(){
21 //在其他类中创建一个静态内部类
22 OuterClass.StaticInnerClass aStaticInnerClass = new OuterClass.StaticInnerClass();
23
24 //在其他类中创建一个非静态内部类
25 //OuterClass.InnerClass aInnerClass = new OuterClass.InnerClass();//错误，必须用一个外部类的实例new一个非静态内部类
26 OuterClass.InnerClass aInnerClass = new OuterClass().new InnerClass();
27 }
28}
29
30//称OuterClass类为外部类
31class OuterClass{
32 static class StaticInnerClass{
33 }
34 class InnerClass{
35 }
36
37 public void method(){
38 StaticInnerClass aStaticInnerClass = new StaticInnerClass();
39 //以下两个表明加不加OuterClass无所谓，对比其他类（其他类必须加OuterClass）
40 OuterClass.StaticInnerClass bStaticInnerClass = new StaticInnerClass();
41 StaticInnerClass cStaticInnerClass = new OuterClass.StaticInnerClass();
42
43 InnerClass aInnerClass = new InnerClass();
44 }
45
46 public static void test(){
47 StaticInnerClass aStaticInnerClass = new StaticInnerClass();
48 //以下两个表明加不加OuterClass无所谓，对比其他类（其他类必须加OuterClass）
49 OuterClass.StaticInnerClass bStaticInnerClass = new StaticInnerClass();
50 StaticInnerClass cStaticInnerClass = new OuterClass.StaticInnerClass();
51
52 //InnerClass aInnerClass = new InnerClass();//错误，在静态方法中不能直接创建非静态内部类，必须要有外部类的实例
53 OuterClass.InnerClass aInnerClass = new OuterClass().new InnerClass();
54 }
55}
56
57
