概述

匿名內部類和 Lambda 表達式都是 Java 中實現特定功能的匿名類。它們在功能上有些相似，但也存在一些關鍵差異。本文將對這兩個概念進行比較，并探討在不同情況下何時使用每種方法。

匿名內部類

匿名內部類是未命名且繼承自特定類型的匿名類。它們通常用于實現接口或抽象類，并可以訪問包含它們的外部類的成員。

優點：

可以訪問外部類的成員。可以實現接口和抽象類?？梢灾貙懜割愔械姆椒?。

缺點：

代碼冗長且難以閱讀。不能在編譯時檢查類型安全性。不能使用類型推斷。

示例：

java// 創建一個匿名內部類來實現 Runnable 接口Runnable runnable = new Runnable() {@OverrIDEpublic void run() {System.out.println("Hello from anonymous inner class!");}};```

Lambda 表達式

Lambda 表達式是使用箭頭語法（->）定義的匿名函數。它們可以接受參數并返回一個值。

優點：

代碼簡潔且易于閱讀。類型安全性在編譯時得到檢查?？梢允褂妙愋屯茢?。

缺點：

不能訪問外部類的成員。不能實現接口和抽象類。不能重寫父類中的方法。

示例：

```java// 創建一個 Lambda 表達式來實現 Runnable 接口Runnable runnable = () -> System.out.println("Hello from lambda expression!");```

異同

下表總結了匿名內部類和 Lambda 表達式之間的異同：| 特征 | 匿名內部類 | Lambda 表達式 ||---|---|---|| 語法 | `new ClassName() {...}` | `(parameters) -> {...}` || 訪問外部類的成員 | 是 | 否 || 實現接口和抽象類 | 是 | 否 || 重寫父類的方法 | 是 | 否 || 類型安全性 | 編譯時檢查 | 編譯時檢查 || 類型推斷 | 否 | 是 || 代碼可讀性 | 冗長 | 簡潔 |

何時使用匿名內部類

當需要訪問外部類的成員時。當需要實現接口或抽象類時。當需要重寫父類中的方法時。

何時使用 Lambda 表達式

當不需要訪問外部類的成員時。當需要一個簡單的函數式接口實現時。當代碼可讀性和簡潔性非常重要時。

結論

匿名內部類和 Lambda 表達式都是 Java 中創建匿名類的兩種強大方法。它們具有不同的功能和優點，在不同的情況下使用。通過了解它們的異同，開發人員可以做出明智的決定，選擇最適合其需求的方法。

---

Java 8的新特性lambda表達式是否比匿名內部類具有更好的可讀性

對于大多數剛剛接觸jdk8的同學來說，應該都會認為lambda表達式其實就是匿名內部類的語法糖(包括我自己，在剛剛接觸的時候，也是這樣認為的)，但實際上二者還是存在不少差異，其中最主要的兩點就是標識性和作用域。 首先，內部類在創建表達式時，會確保創建一個擁有唯一標識的新對象，而對于lambda，其計算結果（其實就是一個映射的過程）可能有也可能沒有唯一標識，這取決于具體實現。 其次，內部類的聲明會創建出一個新的命名作用域，在這個作用域中，this與super指向內部類本身的當前實例；但是lambda恰恰相反，它不會引入任何新的命名環境，這樣就避免了內部類名稱查找的復雜性，名稱查找會導致很多問題，比如想要調用外圍實例的方法時卻錯誤的調用了內部類實例的Object方法。

局部類、匿名類（匿名內部類）lambda、JavaScript箭頭函數之間的關系

匿名類 AnonymousClass

匿名類可以使你的代碼更加簡潔 (JDK8之后Lambda更簡潔)。

定義一個類的同時對其進行實例化。

它與局部類很相似，不同的是它沒有類名，如果某個局部類你只需要使用一次，就可以使用匿名類代替局部類。

匿名類是表達式，而非常規的類

匿名類的使用場景：

一個局部類只需要使用一次的時候

由于匿名類沒有類名，那么除了定義它的地方，其他地方無法調用，所以匿名類也可以叫匿名內部類

匿名類實現HelloWorld接口并創建了實例化對象：frenchGreeting */ HelloWorld frenchGreeting = new HelloWorld() { String name = 無參;

@Override public void greet() { greetSomeone(name); }

@Override public void greetSomeone(String someone) { name = someone; (匿名類： + name); } };

// 匿名類：無參方法 (); // 匿名類：帶參方法 (帶參);

###匿名類繼承父類 (匿名子類)```jspublic class ExtendTest {public static void main(String[] args) {String name = 李四;// 創建父類對象，打印原始name值PartherClass partherClass = new PartherClass();(父類的getName方法= + ());// 使用匿名類繼承父類，并打印name值PartherClass pc = new PartherClass(name){@Overridepublic String getName(){return 匿名類 - +();}};(());}}class PartherClass{private String name = 張三;public PartherClass(){}public PartherClass(String name){ = name;}public String getName(){return ;}}局部類public class HelloWorldAnonymousClasses {interface HelloWorld {public void greet();public void greetSomeone(String someone);}/** * 1、局部類:EnglishGreeting實現了HelloWorld接口 */class EnglishGreeting implements HelloWorld {String name = 無參;@Overridepublic void greet() {greetSomeone(name);}@Overridepublic void greetSomeone(String someone) {name = someone;(局部類： + name);}}// 創建局部類EnglishGreeting的實例化對象，使用接口類型接收HelloWorld englishGreeting = new EnglishGreeting();// 局部類：無參方法();// 局部類：帶參方法(帶參);匿名類的擴展：Java的lambda表達式 （Lambda表達式本身就是一個接口的實現）

Lambda 表達式的作用其實就是匿名方法，而 Java 中并沒有匿名方法這一語法。 不過 Java 中有匿名對象， 當你直接 new 一個接口并實現接口方法的時候，Java 編譯器實際是產生了一個類（匿名類）來實現這個接口，然后再返回這個類的一個實例， 也就是匿名對象;

匿名類實現方式：@Functionalinterfaceinterface HelloWorldFunction {void doSomeWork();}//new 一個接口并實現接口方法的時候，Java 編譯器實際是產生了一個類 匿名類 來實現這個接口staticHelloWorldFunction helloWorldFunction = new HelloWorldFunction() {@Overridepublic void doSomeWork() {(doSomeWork--);}};函數式編程實現方式：static HelloWorldFunction helloWorldFunction = ()-> (doSomeWork--);箭頭函數（箭頭函數就是lambda表達式，提供了更簡潔的function定義方式）Lambda 表達式的主要形式是如下定義，符號的左側是參數，右側是表達式或語句塊。(參數列表) => { 語句塊 }(參數列表) => 語句// 一條語句java lamda 表達式（將匿名函數復制給變量的簡寫方式的函數稱為 lambda 表達式**。）@FunctionalInterfacepublic interface WorkerInterface {public void doSomeWork();}public class WorkerInterfaceTest {public static void execute(WorkerInterface worker) {();}public static void main(String [] args) {//invoke doSomeWork using Annonymous classexecute(new WorkerInterface() {@Overridepublic void doSomeWork() {(Worker invoked using Anonymous class);}});//invoke doSomeWork using Lambda expressionexecute( () -> (Worker invoked using Lambda expression) );}}

函數式接口

1）Java8中Iterable的foreach(Comsumer action)的函數式接口 2）Java8中Iteror的forEachRemaining(Comsumer action)的函數式接口 3)Java8中函數式接口Predicate；Collections的removeIf(Predicate filter)

javascript 箭頭函數var fun1 = funcation(int x,int y){return (x+y);}

簡寫如下：

var fun1 = (x,y)=>x+y;結論：- 箭頭函數適合于無復雜邏輯或者無副作用的純函數場景下，例如用在map、reduce、filter的回調函數定義中；

不要在最外層定義箭頭函數，因為在函數內部操作this會很容易污染全局作用域。最起碼在箭頭函數外部包一層普通函數，將this控制在可見的范圍內；

參考：02、Java的lambda表達式和JavaScript的箭頭函數 - 掘金 ()

原文：

匿名類與內部類

分類:電腦/網絡 >> 程序設計 >> 其他編程語言 問題描述: 內部類的使用有什么優點，什么情況下應考慮使用它呢？ 匿名類使用有什么優點，什么情況下應考慮使用它呢？ 解析: 提起Java內部類（Inner Class）可能很多人不太熟悉，實際上類似的概念在C++里也有，那就是嵌套類（Nested Class），關于這兩者的區別與聯系，在下文中會有對比。 內部類從表面上看，就是在類中又定義了一個類（下文會看到，內部類可以在很多地方定義），而實際上并沒有那么簡單，乍看上去內部類似乎有些多余，它的用處對于初學者來說可能并不是那么顯著，但是隨著對它的深入了解，你會發現Java的設計者在內部類身上的確是用心良苦。 學會使用內部類，是掌握Java高級編程的一部分，它可以讓你更優雅地設計你的程序結構。 下面從以下幾個方面來介紹： 第一次見面public interface Contents { int value(); } public interface Destination { String readLabel(); } public class Goods { private class Content implements Contents { private int i = 11; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new GDestination(s); } public Contents cont() { return new Content(); } } class TestGoods { public static void main(String[] args) { Goods p = new Goods(); Contents c = (); Destination d = (Beijing); } } 在這個例子里類Content和GDestination被定義在了類Goods內部，并且分別有著protected和private修飾符來控制訪問級別。 Content代表著Goods的內容，而GDestination代表著Goods的目的地。 它們分別實現了兩個接口Content和Destination。 在后面的main方法里，直接用 Contents c和Destination d進行操作，你甚至連這兩個內部類的名字都沒有看見！這樣，內部類的第一個好處就體現出來了——隱藏你不想讓別人知道的操作，也即封裝性。 同時，我們也發現了在外部類作用范圍之外得到內部類對象的第一個方法，那就是利用其外部類的方法創建并返回。 上例中的cont()和dest()方法就是這么做的。 那么還有沒有別的方法呢？當然有，其語法格式如下： outerObject=new outerClass(Constructor Parameters); innerObject= InnerClass(Constructor Parameters); 注意在創建非靜態內部類對象時，一定要先創建起相應的外部類對象。 至于原因，也就引出了我們下一個話題—— 非靜態內部類對象有著指向其外部類對象的引用 對剛才的例子稍作修改： public class Goods { private valueRate=2; private class Content implements Contents { private int i = 11*valueRate; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new GDestination(s); } public Contents cont() { return new Content(); } } 修改的部分用藍色顯示了。 在這里我們給Goods類增加了一個private成員變量valueRate，意義是貨物的價值系數，在內部類Content的方法value()計算價值時把它乘上。 我們發現，value()可以訪問valueRate，這也是內部類的第二個好處——一個內部類對象可以訪問創建它的外部類對象的內容，甚至包括私有變量！這是一個非常有用的特性，為我們在設計時提供了更多的思路和捷徑。 要想實現這個功能，內部類對象就必須有指向外部類對象的引用。 Java編譯器在創建內部類對象時，隱式的把其外部類對象的引用也傳了進去并一直保存著。 這樣就使得內部類對象始終可以訪問其外部類對象，同時這也是為什么在外部類作用范圍之外向要創建內部類對象必須先創建其外部類對象的原因。 有人會問，如果內部類里的一個成員變量與外部類的一個成員變量同名，也即外部類的同名成員變量被屏蔽了，怎么辦？沒事，Java里用如下格式表達外部類的引用： 有了它，我們就不怕這種屏蔽的情況了。 靜態內部類 和普通的類一樣，內部類也可以有靜態的。 不過和非靜態內部類相比，區別就在于靜態內部類沒有了指向外部的引用。 這實際上和C++中的嵌套類很相像了，Java內部類與C++嵌套類最大的不同就在于是否有指向外部的引用這一點上，當然從設計的角度以及以它一些細節來講還有區別。 除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。 不過靜態內部類中卻可以擁有這一切。 這也算是兩者的第二個區別吧。 局部內部類 是的，Java內部類也可以是局部的，它可以定義在一個方法甚至一個代碼塊之內。 public class Goods1 { public Destination dest(String s) { class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } return new GDestination(s); } public static void main(String[] args) { Goods1 g= new Goods1(); Destination d = (Beijing); } } 上面就是這樣一個例子。 在方法dest中我們定義了一個內部類，最后由這個方法返回這個內部類的對象。 如果我們在用一個內部類的時候僅需要創建它的一個對象并創給外部，就可以這樣做。 當然，定義在方法中的內部類可以使設計多樣化，用途絕不僅僅在這一點。 下面有一個更怪的例子： public class Goods2{ private void internalTracking(boolean b) { if(b) { class TrackingSlip { private String id; TrackingSlip(String s) { id = s; } String getSlip() { return id; } } TrackingSlip ts = new TrackingSlip(slip); String s = (); } } public void track() { internalTracking(true); } public static void main(String[] args) { Goods2 g= new Goods2(); (); } } 你不能在if之外創建這個內部類的對象，因為這已經超出了它的作用域。 不過在編譯的時候，內部類TrackingSlip和其他類一樣同時被編譯，只不過它由它自己的作用域，超出了這個范圍就無效，除此之外它和其他內部類并沒有區別。 匿名內部類 java的匿名內部類的語法規則看上去有些古怪，不過如同匿名數組一樣，當你只需要創建一個類的對象而且用不上它的名字時，使用內部類可以使代碼看上去簡潔清楚。 它的語法規則是這樣的： new interfacename(){......}; 或 new superclassname(){......}; 下面接著前面繼續舉例子： public class Goods3 { public Contents cont(){ return new Contents(){ private int i = 11; public int value() { return i; } }; } } 這里方法cont()使用匿名內部類直接返回了一個實現了接口Contents的類的對象，看上去的確十分簡潔。 在Java的事件處理的匿名適配器中，匿名內部類被大量的使用。 例如在想關閉窗口時加上這樣一句代碼： (new WindowAdapter(){ public void windowClosing(WindowEvent e){ (0); } }); 有一點需要注意的是，匿名內部類由于沒有名字，所以它沒有構造函數（但是如果這個匿名內部類繼承了一個只含有帶參數構造函數的父類，創建它的時候必須帶上這些參數，并在實現的過程中使用super關鍵字調用相應的內容）。 如果你想要初始化它的成員變量，有下面幾種方法： 如果是在一個方法的匿名內部類，可以利用這個方法傳進你想要的參數，不過記住，這些參數必須被聲明為final。 將匿名內部類改造成有名字的局部內部類，這樣它就可以擁有構造函數了。 在這個匿名內部類中使用初始化代碼塊。 為什么需要內部類？ java內部類有什么好處？為什么需要內部類？ 首先舉一個簡單的例子，如果你想實現一個接口，但是這個接口中的一個方法和你構想的這個類中的一個方法的名稱，參數相同，你應該怎么辦？這時候，你可以建一個內部類實現這個接口。 由于內部類對外部類的所有內容都是可訪問的，所以這樣做可以完成所有你直接實現這個接口的功能。 不過你可能要質疑，更改一下方法的不就行了嗎？ 的確，以此作為設計內部類的理由，實在沒有說服力。 真正的原因是這樣的，java中的內部類和接口加在一起，可以的解決常被C++程序員抱怨java中存在的一個問題——沒有多繼承。 實際上，C++的多繼承設計起來很復雜，而java通過內部類加上接口，可以很好的實現多繼承的效果。 本文的目的只是向大家介紹一下內部類的概念以及使用方法，在后續文章里，將會針對本文中的內容舉更多具體的例子，以及介紹如何使用內部類構建一個Applicaton Framework。

javalambda表達式是什么？

Java Lambda表達式是一種簡潔的代碼塊表示形式，它允許以更加簡潔的方式表示匿名函數。

Java Lambda表達式是Java SE 8及以后版本中引入的一個新特性。 與傳統的匿名內部類相比，Lambda表達式提供了更簡潔、更靈活的代碼表示方式。 其主要特點是：

1. 定義方式

Lambda表達式允許我們定義一個簡短的函數代碼塊，而無需為其創建一個正式的方法。 它使用箭頭符號來分隔參數列表和函數體。

2. 參數和函數體

Lambda表達式的參數列表定義輸入的參數，而箭頭后面的代碼塊則是函數的實現部分。 根據函數的復雜性和需求，Lambda表達式可以有不同的形式，包括無參數、一個參數或多個參數。

3. 匿名函數的特點

Lambda表達式表示的匿名函數可以用于多種場合，例如作為參數傳遞給其他方法，或者在集合中使用進行數據處理等。 這種靈活性使得Lambda表達式成為實現各種功能的一種強大工具。

舉個例子，假設我們有一個列表的排序需求，可以使用Lambda表達式來實現比較邏輯：

List names = ;

-> ); // 使用Lambda表達式作為排序規則

在這個例子中，Lambda表達式` -> `定義了排序的規則，使得我們可以直接對列表進行排序，無需定義額外的比較方法。 這種簡潔的寫法正是Lambda表達式的魅力所在。

Lambda 表達式

Lambda 表達式是 JDK8 的一個新特性，可以取代大部分的匿名內部類，寫出更優雅的 Java 代碼，尤其在集合的遍歷和其他集合操作中，可以極大地優化代碼結構。 JDK 也提供了大量的內置函數式接口供我們使用，使得 Lambda 表達式的運用更加方便、高效。

在創建線程并啟動時可以使用匿名內部類的寫法；

IntBinaryOperator是一個接口，使用匿名內部類的寫法調用該方法；

IntPredicate是一個接口。先使用匿名內部類的寫法調用該方法；

Function是一個接口，先使用匿名內部類的寫法調用該方法；

IntConsumer是一個接口，先使用匿名內部類的寫法調用該方法；

Stream將要處理的元素集合看作一種流，在流的過程中，借助Stream API對流中的元素進行操作。

Stream可以由數組或集合創建，對流的操作分為兩種：

Stream特性：

Stream創建方式有三種：

map，可以將一個流的元素按照一定的映射規則映射到另一個流中；

map，接收一個函數作為參數，該函數會被應用到每個元素上，并將其映射成一個新的元素。

filter，對流中的元素進行條件過濾，符合過濾條件的才能繼續留在流中；

filter，按照一定的規則校驗流中的元素，將符合條件的元素提取到新的流中的操作。

distinct，去除流中的重復元素；

sorted()，自然排序，流中元素需實現Comparable接口；

sorted(Comparator com)，Comparator排序器自定義排序。

limit，可以設置流的最大長度，超出的部分將被拋棄；

skip，跳過流中的前n個元素，返回剩下的元素；

flatMap，接收一個函數作為參數，將流中的每個值都換成另一個流，然后把所有流連接成一個流；

map只能把一個對象轉換成另一個對象來作為流中的元素。 而flatMap可以把一個對象轉換成多個對象作為流中的元素。

forEach方法，通過 Lambda 表達式的方式遍歷集合中的元素；

forEach，對流中的元素進行遍歷操作，通過傳入的參數去指定對遍歷到的元素進行什么具體操作。

count，用來獲取當前流中元素的個數；

max&min，可以用來或者流中的最值。

collect，把當前流轉換成一個集合；

collect，把一個流收集起來，最終可以是收集成一個值也可以收集成一個新的集合；流不存儲數據，那么在流中的數據完成處理后，需要將流中的數據重新歸集到新的集合里。

reduce，把一個流縮減成一個值，能實現對集合求和、求乘積和求最值操作；

reduce，對流中的數據按照你指定的計算方式計算出一個結果。

文章來自

---

---

相關標簽： 匿名內部類與內部類的區別、 lambda、 匿名內部類與、 異同以及何時使用每種方法、 表達式的比較、

上一篇：匿名內部類的常見陷阱避免錯誤，確保代碼健壯

下一篇：深入探究匿名內部類的用途超越事件處理的廣