內部類：是指在類的內部又定義了一個類。根據位置的不同可以分為成員內部類和區域性內部類。

成員內部類

在成員變數的位置定義一個類。
1. 依賴外部類物件存在
2. 可以訪問外部類的成員變數和成員方法。

訪問方式：
1. 直接訪問，直接使用變數名和方法名
2. 通過外部類名.this.變數名／方法名

package test;

public class Outer {
    private int num = 1;
    public void before() {
        System.out.println("before");
    }
    // 成員變數，成員方法，成員內部類是一樣
 

    public class Inner{
        private int count = 2;
        private int num = 2;
        public void speak() {
            System.out.println(num);                // 2
            System.out.println(Outer.this.num);     // 1
            before();                               // before
            System.out.println(count);              // 2
 

        }
        public Inner() {
            super();
        }
    }
}

編譯生成Outer.class和Outer$Inner.class兩個class檔案
用javap -c Outer$Inner.class 命令反編譯檢視

public class test.Outer$Inner {
  final test.Outer this$0;

  public void speak();
    Code:
       0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
 

       3: aload_0
       4: getfield      #19                 // Field num:I
       7: invokevirtual #21                 // Method java/io/PrintStream.println:(I)V
      10: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
      13: aload_0
      14: getfield      #27                 // Field this$0:Ltest/Outer;
      17: invokestatic  #29                 // Method test/Outer.access$0:(Ltest/Outer;)I
      20: invokevirtual #21                 // Method java/io/PrintStream.println:(I)V
      23: aload_0
      24: getfield      #27                 // Field this$0:Ltest/Outer;
      27: invokevirtual #35                 // Method test/Outer.before:()V
      30: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
      33: aload_0
      34: getfield      #38                 // Field count:I
      37: invokevirtual #21                 // Method java/io/PrintStream.println:(I)V
      40: return

  public test.Outer$Inner(test.Outer);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #27                 // Field this$0:Ltest/Outer;
       5: aload_0
       6: invokespecial #46                 // Method java/lang/Object."<init>":()V
       9: aload_0
      10: iconst_2
      11: putfield      #38                 // Field count:I
      14: aload_0
      15: iconst_2
      16: putfield      #19                 // Field num:I
      19: return
}

在編譯成class檔案的過程，編譯器會自己在Inner類中生成一個指向父類物件的引用，並且只含一個有外部類型別的引數的構造方法。
所以看到這就明白了為何內部類能訪問外部類物件的成員變數和方法，並且依賴外部類物件存在。

靜態成員內部類

在成員內部類的基礎上加上了static關鍵字修飾
1.不依賴外部類物件存在
2.只能訪問外部類的靜態成員變數和靜態方法。
訪問方式：
1. 直接訪問，直接使用變數名和方法名
2. 通過外部類名.變數名／方法名

package test;

public class Outer {

    private static int num = 1;
    public void before() {
        System.out.println("before");
    }
    // 靜態成員內部類
    public static class Inner{
        private int count = 2;
        private int num = 2;
        public void speak() {
            System.out.println(num);                // 2
            System.out.println(Outer.num);          // 通過類名的方式訪問
            System.out.println(count);              // 2
        }
        public Inner() {
            super();
        }
    }
}

建立內部類物件： Outer.Inner inner = new Outer().new Inner();
編譯生成Outer.class和Outer$Inner.class兩個class檔案
用javap -c Outer$Inner.class 命令反編譯檢視

public class test.Outer$Inner {
  public void speak();
    Code:
       0: getstatic     #11                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #17                 // Field num:I
       7: invokevirtual #19                 // Method java/io/PrintStream.println:(I)V
      10: getstatic     #11                 // Field java/lang/System.out:Ljava/io/PrintStream;
      13: invokestatic  #25                 // Method test/Outer.access$0:()I
      16: invokevirtual #19                 // Method java/io/PrintStream.println:(I)V
      19: getstatic     #11                 // Field java/lang/System.out:Ljava/io/PrintStream;
      22: aload_0
      23: getfield      #31                 // Field count:I
      26: invokevirtual #19                 // Method java/io/PrintStream.println:(I)V
      29: return

  public test.Outer$Inner();
    Code:
       0: aload_0
       1: invokespecial #38                 // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_2
       6: putfield      #31                 // Field count:I
       9: aload_0
      10: iconst_2
      11: putfield      #17                 // Field num:I
      14: return
}

發現靜態成員內部類沒有外部類物件的引用，所以不能訪問外部類物件的非靜態的成員變數和方法。它是相當一個獨立的類，但限制了訪問方式，要通過外部類訪問內部類。此時內部類相當於外部類的靜態成員.
建立內部類物件：Outer.Inner inner = new Outer.Inner();

成員內部類

在方法中宣告的一個類

package test;

public class Outer2 {
    private int num = 1;

    public void print() {
        System.out.println("Outer的print");
    }

    public void fun() {

        // 區域性內部類
        class Inner{
            public void print() {
                System.out.println("Inner的print");
            }
            public void test() {
                Outer2.this.print();    // 呼叫外部類物件的方法
            }
        }
        new Inner().print();
        new Inner().test();
    }
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        outer2.fun();
    }
}

執行結果如下

Inner的print
Outer的print

開啟反編譯工具檢視下程式碼

class test.Outer2$1Inner {
  final test.Outer2 this$0;

  test.Outer2$1Inner(test.Outer2);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #10                 // Field this$0:Ltest/Outer2;
       5: aload_0
       6: invokespecial #12                 // Method java/lang/Object."<init>":()V
       9: return

  public void print();
    Code:
       0: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #26                 // String Inner的print
       5: invokevirtual #28                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public void test();
    Code:
       0: aload_0
       1: getfield      #10                 // Field this$0:Ltest/Outer2;
       4: invokevirtual #35                 // Method test/Outer2.print:()V
       7: return
}

同樣區域性內部類含有外部類物件的引用並且有且僅有一個含有外部類型別的引數的構造方法，和成員內部類是一樣的。

和成員內部類的區別就是，成員內部類物件可以在其他的類中建立，而區域性內部類只能在方法宣告並建立，作用域在一個方法中。