匿名内部类的优势和劣势：仔细权衡，做出明智的选择 (匿名内部类的写法)

简介

匿名内部类是一种简洁而强大的 Java 特性，允许您定义和实例化内部类，而无需为其显式声明名称。它们通常用于实现回调接口或快速创建匿名类。但是，使用匿名内部类也有一些需要注意的优点和缺点。

匿名内部类的优势

简洁性：匿名内部类无需声明名称，这消除了冗余代码，使代码更简洁、更易于阅读。可读性：由于匿名内部类的定义与使用位置紧密相连，因此它们可以提高代码的可读性和可理解性。灵活性：匿名内部类允许您根据需要动态创建类，无需预先声明它们，这提供了很大的灵活性。避免名称冲突：匿名内部类通过消除对明确名称的需求，有助于避免名称空间中的潜在冲突。实现回调：匿名内部类是实现回调接口的理想选择，它使您可以定义事件处理程序或其他类型的回调，而无需创建单独的类。

匿名内部类的劣势

调试困难：匿名内部类没有明确的名称，这使得它们在调试期间跟踪和识别变得困难。可维护性：匿名内部类可能难以维护，因为它们与外部代码紧密耦合，并且随着时间的推移可能会变得难以管理。性能开销：匿名内部类会产生一些性能开销，因为 Java 虚拟机必须在运行时动态生成它们。有限的作用域：匿名内部类的作用域仅限于其定义点，这可能会限制它们的可用性。混淆性：在某些情况下，匿内部类可能会使代码更难理解，特别是对于不熟悉此概念的开发人员。

何时使用匿名内部类

匿名内部类最适合用于以下情况：在不需要命名或单独维护的简单临时任务中。实现回调接口，其中需要将代码片段传递给另一个方法。快速创建匿名类，而无需显式声明它们。当代码简洁性、灵活性或避免名称冲突比调试或可维护性更重要时。

何时不使用匿名内部类

以下情况不适合使用匿名内部类：在需要调试或维护的复杂或耗时的任务中。当需要在外部代码中访问或引用内部类时。当性能是至关重要的考量因素时。当代码可读性和可维护性比灵活性或简洁性更重要时。

最佳实践

在使用匿名内部类时，请遵循以下最佳实践：仅在需要时使用它们。保持它们尽可能简洁和简单。避免在它们里面定义复杂或耗时的逻辑。使用清晰且有意义的名称来标识匿名内部类对象。在适当的情况下，使用命名内部类或使用 lambda 表达式作为替代方法。

结论

匿名内部类在 Java 开发中是一个有用的工具，可以提供简洁性、灵活性和其他优势。同样重要的是要了解它们的劣势，并在需要时仔细权衡这些优势。通过明智地使用匿名内部类，开发人员可以提高代码的效率、可读性和可维护性。

---

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，对流中的数据按照你指定的计算方式计算出一个结果。

文章来自

匿名内部类，内部类，静态内部类的区别和联系

Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。 内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。 1、静态内部类定义静态内部类，定义在类中，任何方法外，用static定义；静态内部类只能访问外部类的静态成员。 生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。 静态内部类的对象可以直接生成 in=new ()；而不需要通过生成外部类对象来生成。 这样实际上使静态内部类成为了一个顶级类。 可以定义私有静态内部类。 2、java实现静态内部类注意事项将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。 不过其细节方面仍然有很大的不同。 具体来说，主要有如下几个地方要引起注意。 1）一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。 也就是说，在非静态内部类中不可以声明静态成员2）一般非静态外部类可以随意访问其外部类的成员变量以及方法（包括声明为private的方法），但是如果一个内部类被声明为static，则其在访问包括自身的外部类会有诸多的限制。 静态内部类不能访问其外部类的非静态成员变量和方法 3）在一个类中创建非静态成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。 然后要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。 即在创建静态类内部对象时，不需要其外部类的对象3、静态内部类示例 java在实现LinkedList时使用了如下内部类： public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, { ........ private static class Entry { E element; Entry next; Entry previous; Entry(E element, Entry next, Entry previous) { = element; = next; = previous; } } private Entry addBefore(E e, Entry entry) { Entry newEntry = new Entry(e, entry, ); = newEntry; = newEntry; size++; modCount++; return newEntry; } ........ } 这里即静态内部类的典型用法

在java中，Object o = new Object(){};这个花括号是干什么的？

右边是一种匿名内部类的写法，

new Object(){}代表匿名内部类的一个子对象，{}内的代码依据此处“Object”是否包含抽象方法分两种情况：

1，若Object为接口或含有抽象方法（抽象类）、{}内必须包含该接口的方法实现代码或者说重写该抽象类的抽象方法（抽象类或接口无法实例化）

new Thread(new Runnable(){ //匿名

public void run(){

(runnable run);

如上面这段创建线程并start的代码，new Thread括号内传入的就是一个匿名内部类（匿名对象）。该匿名内部类实现了Runnable接口的run方法，因此可以创建对象并作为Thread构造函数的入参

2，若Object为普通类，{}内可以重写也可以不重写Object里面的方法。要注意的是，这个时候

new Object(){} 整体作为Object对象的一个匿名子类对象

另外，通常来说这种写法，适用于你想重写某个父类的某个方法（或实现某个接口的方法）并调用，但是又不想再创建一个class类来重写（或实现）的时候。通过以下格式来定义：

new 父类名/接口名(){ 定义子类成员或者覆盖父类方法 }.方法

只是比较浅显的回答，具体楼主多翻翻书看看吧、

彻底理解Java内部类的使用（内部类代码实例详解）

前言

内部类相信大家都应该用过，但我也相信大家应该都只是很简单的使用。

所以今天，就来详细讲解内部类的使用，废话不多说，我们先赶紧来看吧。

在普通类中使用内部结构

先来看个示例：

Teacher类里面有个内部类Student：

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Students=newStudent();//实例化内部类的对象();}//在Teacher类中的内部类classStudent{publicvoidprint(){();//msg是Teacher类里面的属性}}}

测试类：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}

输出结果：

我是一名老师Processfinishedwithexitcode0

从整体的代码结构来讲，内部类的结构并不合理，所以内部类本身最大的缺陷在于破坏了程序的结构，但是破坏需要有目的的破坏，那么它也一定会有其优势，如果要想更好的观察出内部类的优势，就可以将内部类拿到外面来。 我将上面的代码Student拿出来。

Teacher类：

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}

Student类：

publicclassStudent{privateTeacherteacher;publicStudent(Teacherteacher){=teacher;}publicvoidprint(){(());//msg是Teacher类里面的属性}}

测试：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}

输出结果：

我是一名老师Processfinishedwithexitcode0

我们折腾了半天主要的目的就是为了让Student这个内部类可以访问Teacher这个类中的私有属性，如果不用内部类的时候整体代码会非常的麻烦，所以可以得出内部类的优点：轻松的访问外部类中的私有属性。

需要注意的是：内部类虽然可以方便的访问外部类中的私有成员或私有方法，同理**，外部类也可以轻松访问内部类中的私有成员或私有方法**。

示例如下：

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent();//实例化内部类的对象();();}classStudent{privateStringinfo=我是一名学生;publicvoidprint(){();}}}publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}

输出结果：

我是一名老师我是一名学生Processfinishedwithexitcode0

使用了内部类之后，内部类与外部类之间的私有操作的访问就不再需要通过setter，getter以及其他的间接方式完成了，可以直接进行操作，但是需要注意的是，内部类本身也属于一个类，虽然在大部分情况下内部类往往是被外部类包裹的，但是外部依然可以产生内部类的实例化对象，而此时，内部类实例化对象的格式如下：

外部类.内部类内部类对象=new外部类（）内部类（）；

在内部类编译完成之后会自动形成一个Teacher$类文件，其中“$”这个符号换到程序中就变为“.”，所以内部类的全称：“外部类.内部类”。 内部类与外部类之间可以直接进行私有成员的访问，这样一来内部类如果要是提供有实例化对象了，一定要先保证外部类实例化了。

publicclassTest{publicstaticvoidmain(String[]args){=newTeacher()();();}}

如果此时Student类只允许Teacher类来使用，那么在这样的情况下就可以使用private进行私有定义。

这样，此时的Student类就无法再外部使用，即在test中的这条语句=newTeacher()()就失效。

在抽象类和接口中使用内部结构

在我们的java之中，类作为最基础的结构体实际上还有与之类似的抽象类或者是接口，抽象类和接口中都可以定义内部结构。

接口中定义内部接口

我们现在定义内部接口：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}0publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}1

测试：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}2

输出结果：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}3接口中定义内部抽象类

下面我们继续观察一个内部抽象类，内部抽象类可以定义在普通类，抽象类，接口内部都可以。

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}4publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}5

测试：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}6

输出结果：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}3用内部类实现外部接口

内部类还有一些更为有意思的结构，即：如果现在定义了一个接口，那么可以在内部利用类实现该接口，在JDK1.8之后，接口中追加了static方法可以不受到实例化对象的控制，现在就可以利用此特性来完成功能。

接口内部进行接口实现：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}8

测试：

publicclassTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();();}}9

输出结果：

我是一名老师Processfinishedwithexitcode00

从上面可以看到，内部类是非常灵活的结构，只要你的语法满足了，各种需求都可以帮你实现！

static定义内部类static定义内部类

如果说现在内部类上使用了static定义，那么这个内部类就变成了外部类，static定义的都是独立于类的结构，所以该类结构就相当于是一个独立的程序类了。 需要注意，static定义的不管是类还是方法只能够访问static成员，所以static定义的内部类只能够访问外部内中的static属性和方法。

我是一名老师Processfinishedwithexitcode01

这个时候的Student类是一个独立类，如果此时要想实例化Student类对象，只需要根据“外部类.内部类”的结构实例化对象即可

格式如下外部类.内部类内部类对象=new外部类.内部类（）；

测试：

我是一名老师Processfinishedwithexitcode02

输出结果：

我是一名老师Processfinishedwithexitcode0

所以以后如果发现类名称上提供有.，首先应该立刻想到这是一个内部类的结构，如果可以直接进行实例化，则应该立刻认识到这是一个static定义的内部类，但是static定义内部类的形式来讲并不常用，static定义内部接口的形式最为常用。

static定义内部接口我是一名老师Processfinishedwithexitcode04我是一名老师Processfinishedwithexitcode05我是一名老师Processfinishedwithexitcode06

测试：

我是一名老师Processfinishedwithexitcode07

输出结果：

我是一名老师Processfinishedwithexitcode08方法中定义内部类

内部类可以在任意的结构中定义，这就包括了：类中、方法中、代码块中。 但在方法中定义内部类的情况比较多。

我是一名老师Processfinishedwithexitcode09publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}0

输出结果：

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}1

此时在say方法内部提供有Student内部类的定义，并且发现内部类可以直接访问外部类中的私有属性也可以直接访问方法中的参数，但对于方法中的参数直接访问时从JDK1.8开始支持的。 而在JDK1.8之前**，如果方法中定义的内部类要想访问方法中的参数则参数前必须追加final。 **

之所以取消这样的限制是为了扩展函数式编程准备的。

匿名内部类

匿名类是一种简化的内部类的处理形式，其主要是在抽象类和接口的子类上使用的。

接口和抽象类是一样的。

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}2publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}3publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}4

如果说现在Study接口中的XiaoMing子类只使用唯一的一次，那么是否还有必要将其定义为单独的类？那么在这样的要求下就发现这个时候定义的子类是有些多余了，所以就可以利用内部类的形式来解决此问题。

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}2publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}6

匿名内部类不一定要在抽象类或接口上，但只有在抽象类和接口上才有意义。 有些时候为了更加方便的体现出匿名内部类的使用，往往可以利用静态方法做一个内部类的匿名内部类实现。

在接口中直接定义匿名内部类。

publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}7publicclassTeacher{privateStringmsg=我是一名老师;//只能在类内部访问publicvoidsay(){Studentstudent=newStudent(this);//实例化内部类的对象();}publicStringgetMsg(){;}}8

与内部类相比匿名内部类只是一个没有名字的只能够使用一次的，并且结构固定的一个子类。

总结：

方法，类，抽象类，接口，代码块中都可以定义内部结构——类，抽象类，接口。

本文主要讲了如何在内部类中使用内部类和接口中使用内部类以及如何使用static修饰的内部类和如何在方法中使用内部类。 看完这篇相信你对内部类的理解更加深入了。

作者：初念初恋

java代码：new 类名(){方法定义}应该如何理解？

new 类名(){方法定义} 这种写法是匿名内部类。

1、匿名内部类就是没有名字的内部类。 这是Java为了方便程序员编写程序，而设计的一个机制。 因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适，而且也免去了给它取名字的烦恼。 2、如果满足下面的一些条件，使用匿名内部类是比较合适的： ·只用到类的一个实例。 ·类在定义后马上用到。 ·类非常小（SUN推荐是在4行代码以下） ·给类命名并不会导致你的代码更容易被理解。 在使用匿名内部类时，要记住以下几个原则： ·匿名内部类不能有构造方法。 ·匿名内部类不能定义任何静态成员、方法和类。 ·匿名内部类不能是public,protected,private,static。 ·只能创建匿名内部类的一个实例。 ·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。 ·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。 3、用匿名内部类创建多线程有两种方式，和创建一个线程是一样的。

第①种继承Thread：

---

---

相关标签： 匿名内部类的写法、 匿名内部类的优势和劣势、 做出明智的选择、 仔细权衡、

上一篇：揭开匿名内部类的幕后故事深入了解Java的内

下一篇：揭秘匿名内部类的神秘世界将Java编程提升到