摘要：外部類也可以直接訪問內部類的所有屬性和方法。匿名內部類為局部內部類，所以局部內部類的所有限制同樣對匿名內部類生效。創建內部類對象的時刻并不依賴于外圍類對象的創建。內部類并沒有令人迷惑的關系，他就是一個獨立的實體。

可以將一個類定義在另一個類里面或者一個方法里面，這樣的類稱為內部類。

廣泛意義上的內部類一般來說包括這四種：

成員內部類

局部內部類

靜態內部類

匿名內部類

成員內部類是最普通的內部類，它的定義為位于另一個類的內部，形如下面的形式：

public class testDemo {
    public static void main(String[] args ) {
        Outer t = new Outer();
        Outer.Inner in = t.new Inner(); // 必須先有外部類對象，才能創建內部類
        t.fun();
        in.print();
    }
}

class Outer { //外部類
    private String msg = "hello world";
    
    public void fun(){
       Inner in =  new Inner();
       System.out.println(in.info); //外部類直接訪問內部類的私有屬性
    }

    class Inner{ //定義了一個成員內部類
        private String info = "世界，你好!";
        public void print(){
            System.out.println(msg); //內部類直接訪問外部類的private屬性
        }
    }

}

成員內部類可以無條件訪問外部類的所有屬性和方法（包括private成員和靜態成員）。外部類也可以直接訪問內部類的所有屬性和方法。

成員內部類是依附外部類而存在的，也就是說，如果要創建成員內部類的對象，前提是必須存在一個外部類的對象

在外部類中如果要訪問成員內部類的成員，必須先創建一個成員內部類的對象，再通過指向這個對象的引用來訪問。

不過要注意的是，當成員內部類擁有和外部類同名的成員變量或者方法時，會發生隱藏現象，即默認情況下訪問的是成員內部類的成員。如果要訪問外部類的同名成員，需要以下面的形式進行訪問：

外部類.this.成員變量
外部類.this.成員方法

局部內部類是定義在一個方法或者一個作用域里面的類，它和成員內部類的區別在于局部內部類的作用域僅限于方法內或者該作用域內。

public class testDemo {
    public static void main(String[] args ) {
      new Outer().fun();
    }
}
class Outer { //外部類
    private String msg = "hello world";
    public void fun(){
        class Inner{ //在方法中定義了一個局部內部類
            public void print(){
                System.out.println(Outer.this.msg); //直接訪問外部類的private屬性
            }
        }
        new Inner().print();
    }
}

注意:局部內部類就像是方法里面的一個局部變量一樣。

在jdk1.7或之前的版本，如果局部內部類要訪問方法中定義的參數、局部變量，那么參數和變量前一定要加上"final"修飾符。jdk1.8以及更新的版本則沒有這個限制。

public class testDemo {
    public static void main(String[] args ) {
      new Outer().fun(100);
    }
}

class Outer { //外部類

    private String msg = "hello world";

    public void fun(final int num){
        final double score = 99.9; 
        class Inner{ //在方法中定義了一個局部內部類
            public void print(){
                System.out.println("屬性："+Outer.this.msg); //直接訪問外部類的private屬性
                System.out.println("方法參數"+ num);
                System.out.println("方法局部變量"+ score);
            }
        }
        new Inner().print();
    }

}

使用static修飾的成員內部類叫靜態內部類。靜態內部類是不需要依賴于外部類的，這點和類的靜態成員屬性有點類似，并且它不能訪問外部類的非static成員變量或者方法。

public class testDemo {
    public static void main(String[] args ) {
        Outer.Inner in = new Outer.Inner(); //靜態內部類可以使用"外部類.內部類"的方式使用
        in.print();
    }
}

class Outer { //外部類
    
    static class Inner{ //定義了一個靜態內部類
        private String info = "世界，你好!";
        public void print(){
            System.out.println(info);
        }
    }

}

當某個子類只使用唯一一次的時候，沒有必要多帶帶定義出來，可以使用匿名內部類的方法簡化代碼。

匿名內部類就是沒有名字的局部內部類。創建格式如下：

new 父類構造器（參數列表）| 要實現的接口 () {  
     //匿名內部類的類體部分 
     //....
}

匿名內部類是在抽象類和接口的基礎上發展而來的，其最大的好處是幫助減少了類的定義。

在使用匿名內部類的過程中，我們需要注意如下幾點：

使用匿名內部類時，我們必須是繼承一個類或者實現一個接口，但是兩者不可兼得，同時也只能繼承一個類或者實現一個接口。

匿名內部類中是不能定義構造函數的。

匿名內部類中不能存在任何的靜態成員變量和靜態方法。

匿名內部類為局部內部類，所以局部內部類的所有限制同樣對匿名內部類生效。

匿名內部類不能是抽象的，它必須要實現繼承的類或者實現的接口的所有抽象方法。

當所在的方法的形參需要被內部類里面使用時，該形參必須為final（jdk1.8之后可省略）。

示例:

//接口
 interface Inner {
    public String say();
}
//抽象類
 abstract class Inner1 implements Inner{

}
//普通類
class Inner2 implements Inner{
    public String say(){
        return "this is Inner2";
    }
}

class Outer {
    public void method1(Inner inner) {
        System.out.println(inner.say());
    }
}

public class testDemo {
    public static void main(String[] args) {

        Outer outer = new Outer();
        // 測試1，Inner為接口
        outer.method1(new Inner() {
            String s1 = "this is s1 in Inner";

            public String say() {
                // 外部類和匿名函數類中有同名變量s1
                return s1;
            }
        });

        // 測試2，Inner1為抽象類
        outer.method1(new Inner1() {
            String s2 = "this is s2 in Inner1";

            public String say() {
                // 外部類和匿名函數類中有同名變量s2
                return s2;
            }
        });

        //測試3， Inner2為普通類
        outer.method1(new Inner2() {
            public String say() {
                return "this is inner2 overrite";
            }
        });

    }
}
輸出結果:
this is s1 in Inner
this is s2 in Inner1
this is inner2 overrite

為什么要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外圍類是否已經繼承了某個（接口的）實現，對于內部類都沒有影響。

在我們程序設計中有時候會存在一些使用接口很難解決的問題，這個時候我們可以利用內部類提供的、可以繼承多個具體的或者抽象的類的能力來解決這些程序設計問題。可以這樣說，接口只是解決了部分問題，而內部類使得多重繼承的解決方案變得更加完整。內部類最大的優點就在于它能夠非常好的解決多重繼承的問題.

內部類還能夠為我們帶來如下特性：

內部類可以用多個實例，每個實例都有自己的狀態信息，并且與其他外圍對象的信息相互獨立。

在單個外圍類中，可以讓多個內部類以不同的方式實現同一個接口，或者繼承同一個類。

創建內部類對象的時刻并不依賴于外圍類對象的創建。

內部類并沒有令人迷惑的“is-a”關系，他就是一個獨立的實體。