在我们日常java编程中，内部类用到的相对比较少，但是也有必要了解下。注：本篇测试Jdk版本为1.7
1、内部类简述在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类一般来说分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。
（1）成员内部类
class Outter {
private double i = 1;
public static int j = 2;
//内部类
class Inner {
public void InnerFunction() {
System.out.println("innerFunction...");
//访问外部类的private成员
System.out.println(i);
//访问外部类的静态成员
System.out.println(j);
}
}
}
类Inner位于类Outter的内部，像是类Outter的一个成员，Outter称为外部类，Inner成为内部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
注意：当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问。
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。
创建成员内部类对象的一般方式如下：
package com.testinner;
public class Test {
public static void main(String[] args) {
Outter o = new Outter();
//第一种方式
Outter.Inner i = o.getInnerInstance();
//第二种方式
Outter.Inner i2 = o.new Inner();
}
}
class Outter {
private double i = 1;
public static int j = 2;
public void outterFunction() {
System.out.println("outterFunction...");
getInnerInstance().innerFunction();
}
public Inner getInnerInstance() {
return new Inner();
}
//内部类
class Inner {
public void innerFunction() {
System.out.println("innerFunction...");
//访问外部类的private成员
System.out.println(i);
//访问外部类的静态成员
System.out.println(j);
}
}
}
内部类可以拥有private、protected、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类Outter的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。
（2）局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
class People {
}
class Boy {
public People getGirl() {
class Girl extends People {
int age = 18;
}
return new Girl();
}
}
注意：局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
（3）匿名内部类
匿名内部类应该是平时我们编写代码时用得最多的，比如多线程编程时：
package com.testinner;
public class Test {
public static void main(String[] args) {
new Thread() {
public void run() {
System.out.println("我是一个匿名内部类...");
};
}.start();
}
}
匿名内部类不能有访问修饰符和static修饰符的。匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的重写或是实现。
（4）静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
（1）为什么成员内部类可以无条件访问外部类的成员？
在此之前，我们已经讨论过了成员内部类可以无条件访问外部类的成员，那具体究竟是如何实现的呢？下面通过反编译字节码文件看看究竟。事实上，编译器在进行编译的时候，会将成员内部类单独编译成一个字节码文件，看下面代码：
package com.testinner;
public class Test {
public static void main(String[] args) {
}
}
class Outter {
private double i = 1;
public static int j = 2;
//内部类
class Inner {
public void innerFunction() {
System.out.println("innerFunction...");
//访问外部类的private成员
System.out.println(i);
//访问外部类的静态成员
System.out.println(j);
}
}
}
编译后出现三个class文件：
反编译Outter$Inner.class文件得到下面信息：
C:\eclipseProjects\Test\bin\com\testinner>javap -v Outter$Inner
警告: 二进制文件Outter$Inner包含com.testinner.Outter$Inner
Classfile /C:/eclipseProjects/Test/bin/com/testinner/Outter$Inner.class
Last modified 2020-8-1; size 800 bytes
MD5 checksum d12eb937e9c95559ee107c15c92f6beb
Compiled from "Test.java"
class com.testinner.Outter$Inner
minor version: 0
major version: 51
flags: ACC_SUPER
Constant pool:
#1 = Class #2 // com/testinner/Outter$Inner
#2 = Utf8 com/testinner/Outter$Inner
#3 = Class #4 // java/lang/Object
#4 = Utf8 java/lang/Object
#5 = Utf8 this$0
#6 = Utf8 Lcom/testinner/Outter;
#7 = Utf8 <init>
#8 = Utf8 (Lcom/testinner/Outter;)V
#9 = Utf8 Code
#10 = Fieldref #1.#11 // com/testinner/Outter$Inner.this$0:Lcom/testinner/Outter;
#11 = NameAndType #5:#6 // this$0:Lcom/testinner/Outter;
#12 = Methodref #3.#13 // java/lang/Object."<init>":()V
#13 = NameAndType #7:#14 // "<init>":()V
#14 = Utf8 ()V
#15 = Utf8 LineNumberTable
#16 = Utf8 LocalVariableTable
#17 = Utf8 this
#18 = Utf8 Lcom/testinner/Outter$Inner;
#19 = Utf8 innerFunction
#20 = Fieldref #21.#23 // java/lang/System.out:Ljava/io/PrintStream;
#21 = Class #22 // java/lang/System
#22 = Utf8 java/lang/System
#23 = NameAndType #24:#25 // out:Ljava/io/PrintStream;
#24 = Utf8 out
#25 = Utf8 Ljava/io/PrintStream;
#26 = String #27 // innerFunction...
#27 = Utf8 innerFunction...
#28 = Methodref #29.#31 // java/io/PrintStream.println:(Ljava/lang/String;)V
#29 = Class #30 // java/io/PrintStream
#30 = Utf8 java/io/PrintStream
#31 = NameAndType #32:#33 // println:(Ljava/lang/String;)V
#32 = Utf8 println
#33 = Utf8 (Ljava/lang/String;)V
#34 = Methodref #35.#37 // com/testinner/Outter.access$0:(Lcom/testinner/Outter;)D
#35 = Class #36 // com/testinner/Outter
#36 = Utf8 com/testinner/Outter
#37 = NameAndType #38:#39 // access$0:(Lcom/testinner/Outter;)D
#38 = Utf8 access$0
#39 = Utf8 (Lcom/testinner/Outter;)D
#40 = Methodref #29.#41 // java/io/PrintStream.println:(D)V
#41 = NameAndType #32:#42 // println:(D)V
#42 = Utf8 (D)V
#43 = Fieldref #35.#44 // com/testinner/Outter.j:I
#44 = NameAndType #45:#46 // j:I
#45 = Utf8 j
#46 = Utf8 I
#47 = Methodref #29.#48 // java/io/PrintStream.println:(I)V
#48 = NameAndType #32:#49 // println:(I)V
#49 = Utf8 (I)V
#50 = Utf8 SourceFile
#51 = Utf8 Test.java
#52 = Utf8 InnerClasses
#53 = Utf8 Inner
{
final com.testinner.Outter this$0;
descriptor: Lcom/testinner/Outter;
flags: ACC_FINAL, ACC_SYNTHETIC
com.testinner.Outter$Inner(com.testinner.Outter);
descriptor: (Lcom/testinner/Outter;)V
flags:
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #10 // Field this$0:Lcom/testinner/Outter;
5: aload_0
6: invokespecial #12 // Method java/lang/Object."<init>":()V
9: return
LineNumberTable:
line 14: 0
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 this Lcom/testinner/Outter$Inner;
public void innerFunction();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=1, args_size=1
0: getstatic #20 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #26 // String innerFunction...
5: invokevirtual #28 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: getstatic #20 // Field java/lang/System.out:Ljava/io/PrintStream;
11: aload_0
12: getfield #10 // Field this$0:Lcom/testinner/Outter;
15: invokestatic #34 // Method com/testinner/Outter.access$0:(Lcom/testinner/Outter;)D
18: invokevirtual #40 // Method java/io/PrintStream.println:(D)V
21: getstatic #20 // Field java/lang/System.out:Ljava/io/PrintStream;
24: getstatic #43 // Field com/testinner/Outter.j:I
27: invokevirtual #47 // Method java/io/PrintStream.println:(I)V
30: return
LineNumberTable:
line 16: 0
line 18: 8
line 20: 21
line 21: 30
LocalVariableTable:
Start Length Slot Name Signature
0 31 0 this Lcom/testinner/Outter$Inner;
}
SourceFile: "Test.java"
InnerClasses:
#53= #1 of #35; //Inner=class com/testinner/Outter$Inner of class com/testinner/Outter
跳过Constant pool常量池的内容，我们看这行：
final com.testinner.Outter this$0;
这行是一个指向外部类对象的指针。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用，那么这个引用是如何赋初值的呢？下面接着看内部类的构造器：
com.testinner.Outter$Inner(com.testinner.Outter);
从这里可以看出，我们定义的内部类没有定义构造器，默认应该提供一个无参的，但是我们看到编译器会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。
（2）为什么局部内部类和匿名内部类只能访问局部final变量？
在讨论这个问题之前，先看下面这段代码：
package com.testinner;
public class Test {
public static void main(String[] args) {
}
public void test(final int b) {
final int a = 10;
new Thread(){
public void run() {
System.out.println(a);
System.out.println(b);
};
}.start();
}
}
这段代码会被编译成两个class文件：Test.class和Test $ 1.class。默认情况下，编译器会为匿名内部类和局部内部类起名为Outter $ x.class（x为正整数）。
