匿名内部类与 lambda 表达式的比较：异同以及何时使用每种方法 (匿名内部类与内部类的区别)

概述

匿名内部类和 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、 匿名内部类与、 异同以及何时使用每种方法、 表达式的比较、

上一篇：匿名内部类的常见陷阱避免错误，确保代码健壮

下一篇：深入探究匿名内部类的用途超越事件处理的广