用大白话聊聊匿名内部类

肥春勿扰

已于 2023-04-12 23:06:19 修改

阅读量279

点赞数 2

分类专栏： java 文章标签： java

于 2023-04-11 19:25:40 首次发布

本文链接：https://blog.csdn.net/qq_52988841/article/details/130091357

版权

java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

再细说匿名内部类之前，我们想一个问题，我们再用接口的时候是不是需要先让一个类去实现这个接口，而我们在用一个抽象类时，是不是也得让一个类去继承这个抽象类才能用其中抽象方法；我们把这个类叫做老好人吧，每次取用接口中和抽象类当中的抽象方法时都得去委托这个老好人，现在我们想解放这个老好人，于是出现了匿名内部类

一、匿名内部类的定义

最本质的还是一个类
是一个内部类（有关内部类的内容不在这里讲述了）
该类没有名字（但是系统会分配一个代号在内存中

二、匿名内部类的应用场景

假设我们有一个接口A
内部有一个未被实现的方法eat
如果我们想在main中直接调用eat方法
则按照传统思路需要一个类B来实现接口A，同时再创建类B的对象来调用A
代码如下：

public class Interface01 {
    public static void main(String[] args) {
        B b = new B();
        b.eat();
    }
}
interface A{
    public void eat();
}
class B implements A{
    @Override
    public void eat() {
        System.out.println("正在调用eat方法");
    }
}
----------------------
正在调用eat方法

如果我们只是想单纯的使用一次eat方法，不需要创建对象的话，则上面方法略显古板。
此时，便用到了匿名内部类。

public class Interface01 {
    public static void main(String[] args) {
        new A(){
            @Override
            public void eat() {
                System.out.println("正在调用eat方法");
            }
        }.eat();
    }
}
interface A{
    public void eat();
}
----------------------
正在调用eat方法

上面这种写法就可以很好的简化代码的书写
此时的匿名内部类相当于一个对象，所以它的后面可以直接调用eat方法，非常的简便快捷
当A里面有多个方法时，如果想要同时调用，可以采用下面的写法：

public class Interface01 {
    public static void main(String[] args) {
        A a = new A(){
            @Override
            public void eat() {
                System.out.println("正在调用eat方法");
            }
            public void drink(){
                System.out.println("正在调用drink方法");
            }
        };
        a.eat();
        a.drink();
    }
}
interface A{
    public void eat();
    public void drink();
}

而此时我们并没有实例化这个接口的类，便实现了里面的方法，所以称之为匿名内部类
其实，这个类是被临时创建了，在内存中存在系统设定的名字，
我们可以使用下面方法来得到匿名内部类的（名字）

public class Interface01 {
    public static void main(String[] args) {
        A a = new A(){
            @Override
            public void eat() {
                System.out.println("正在调用eat方法");
            }
            public void drink(){
                System.out.println("正在调用drink方法");
            }
        };
        a.eat();
        a.drink();
        System.out.println(a.getClass()); //获取类名
    }
}
interface A{
    public void eat();
    public void drink();
}
-------------------
正在调用eat方法
正在调用drink方法
class com.interface_.Interface01$1

由此可见，这个匿名内部类的名字为Interface01$1，当下一个匿名内部类时，就会变成$2，以此类推

三、匿名内部类的最常使用场景

通过实参的形式来使用，大大简化了代码的书写

public class Interface01 {
    public static void main(String[] args) {
        f(new A() {
            @Override
            public void eat() {
                System.out.println("没有创建对象便成功的调用了f方法，不需要实现接口");
            }
        });
    }
    public static void f(A a){
        a.eat();
    }
}
interface A{
    public void eat();
}
---------------------------
没有创建对象便成功的调用了f方法，不需要实现接口

而按照传统方法则需要：

public class Interface01 {
    public static void main(String[] args) {
        B b = new B();
        f(b);
    }
    public static void f(A a){
        a.eat();
    }
}
interface A{
    public void eat();
}
class B implements A{
    @Override
    public void eat() {
        System.out.println("正在调用eat方法");
    }
}
--------------
正在调用eat方法