今天來看看另一個更加神奇的類——匿名內部類。

就像它的名字表示的那樣，這個類是匿名的，用完之后，深藏功與名，就像掃地僧那樣默默潛藏于深山之中。匿名內部類不僅沒有名字，連class關鍵字都省掉了，而且匿名內部類必須繼承于某個類或者實現某個接口，長的就像這樣：

new 父類（參數列表）|實現接口（） { //匿名內部類的內部定義 }

來看一個栗子：

public abstract class Human { public abstract void walk();}

這是一個抽象類，如果使用匿名內部類來繼承的話是這樣的：

public class AnonymousTest { public static void main(String[] args) { Human human = new Human(){ public void walk(){System.out.println('AnonymousHuman can walk.'); }; }; human.walk(); }}

簡單粗暴，看起來就像局部內部類的簡化版。如果不使用匿名內部類，會是怎樣呢？

我們需要先創建一個類來繼承這抽象類：

public class Man extends Human { @Override public void walk() { System.out.println('Man can walk.'); }}

然后再來使用這個類：

public class AnonymousTest { public static void main(String[] args) { Human human = new Man(); human.walk(); }}

因為一個單獨的類往往放在一個單獨的文件中，如果這個類只需要創建一個對象，那未免有些大材小用了，從上面的栗子可以比較出匿名內部類的一個優勢：在類只需要創建一個對象的情況下更加簡單方便。

再舉一個實際一點的栗子：

public class AnonymousTest { public static void main(String[] args) { Thread t = new Thread() { public void run() {for (int i = 0; i < 10; i++) { try { sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i);} } }; t.start(); }}

這里創建了一個繼承于Thread的匿名內部類，覆蓋了其中的 run方法，并創建了一個實例返回給了t，然后再調用run方法，可以看到，匿名內部類只能存在一個實例對象，因為new過一次就無法再創建了，也許會覺得局部內部類已經很局限了，為什么要出現比局部內部類適用范圍更小的匿名內部類？、

這你就不懂了吧，在Java的實際使用中，匿名內部類大有用處，為什么要使用匿名內部類呢？

有時候，我們創建的類只需要一個實例，比如說在多線程中，要使用多線程，一般先繼承Thread類或者實現Runnable接口，然后再去調用它的方法，而每個任務一般都不一樣，每次都新建一個類顯然會很難管理，因為每個類只用一次就丟掉了，這個時候使用匿名內部類就很方便了，不僅不需要管理一堆一次性類，而且創建起來簡單粗暴。就像上述栗子，還能簡化成這樣：

public class AnonymousTest { public static void main(String[] args) { new Thread() { public void run() {for (int i = 0; i < 10; i++) { try { sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i);} } }.start(); }}

創建實例后直接調用run方法，簡單粗暴。

匿名內部類不僅可以繼承于類，也可以實現于接口，比如說這樣：

public class AnonymousTest { public static void main(String[] args) { new Thread(new Runnable() { public void run() {for (int i = 0; i < 10; i++) { try { sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i);} } }).start(); }}

當然，還有些不得不用內部類的情況，類只能繼承于一個類，如果一個類需要使用到另一個包中的另一個類的一個protected方法，卻已經繼承于另一個類，那么這個時候就不得不用內部類來解決了。

比如說，還有一個Woman（女人）類：

public class Woman { protected void dance(){ System.out.println('Woman can dance.'); }}

這個時候，如果Man（男人）也難不住寂寞，想要dance（跳舞）一下，那該怎么辦呢？繼承Woman類？顯然不合乎邏輯，而且也無法實現，因為已經繼承于Human類了，但就是想要dance，該怎么辦？

內部類的出現讓這個問題變得很簡單：

public class Man extends Human { @Override public void walk() { System.out.println('Man can walk.'); } public void dance(){ new Woman(){ public void manDance(){super.dance(); } }.manDance(); }}

因為在不同的包下，不能直接使用Woman的dance方法，但是可以用內部類來繼承，從而調用protected方法，然后再放入Man的方法中，這樣，Man也能像Woman一樣dance了：

public class AnonymousTest { public static void main(String[] args) { Man human = new Man(); human.walk(); human.dance(); }}

當然，使用匿名內部類還是有很多限制的：

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

2、匿名內部類不能定義構造函數。

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

4、匿名內部類是特殊的局部內部類，所以局部內部類的所有限制同樣對匿名內部類生效。

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

那么問題來了，怎樣初始化一個匿名內部類呢？畢竟匿名內部類是不能有構造器的。

當然，首先，還是可以使用初始化塊來實現的，就像這樣：

public class AnonymousTest { public static void main(String[] args) { Human human = new Human() { private String name; {name = 'human'; } @Override public void walk() {System.out.println(name + ' walk.'); } }; human.walk(); }}

但是這樣顯然就比較呆板，不夠靈活，無法接受外部參數，那么怎樣靈活使用呢？不要心急，方法總比問題多，還是有辦法解決的：

public class AnonymousTest { public static void main(String[] args) { Human human = new AnonymousTest().getHumanInstance('Frank'); human.walk(); } public Human getHumanInstance(final String name){ return new Human() { private String nameA; {nameA = name; } @Override public void walk() {System.out.println(nameA + ' walk.'); } }; }}

這里利用初始化塊來對匿名內部類進行初始化，注意，如果匿名內部類需要使用外部的參數或者變量，那么必須使用final修飾，因為內部類使用的其實是參數的拷貝，并不是參數本身，為了更明顯的表明參數不可變，編譯器會要求使用final關鍵字來修飾需要使用的變量。

至此，匿名內部類講解完畢，歡迎大家繼續關注！

以上就是詳解Java內部類——匿名內部類的詳細內容，更多關于Java 匿名內部類的資料請關注好吧啦網其它相關文章！