什么是匿名内部类，如何使用匿名内部类

匿名内部类

匿名内部类，就是没有名字的一种嵌套类。它是Java对类的定义方式之一。
为什么要使用匿名内部类

在实际开发中，我们常常遇到这样的情况：一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余。

下面详细说明一下

假设当前有一个接口，接口中只有一个方法

public interface Interface01 {
    void show();
}

    1
    2
    3

为了使用该接口的show方法，我们需要去创建一个实现类，同时书写show方法的具体实现方式

public class Interface01Impl implements Interface01{
    @Override
    public void show() {
        System.out.println("I'm a impl class...");
    }
}

    1
    2
    3
    4
    5
    6

如果实现类Interface01Impl全程只使用一次，那么为了这一次的使用去创建一个类，未免太过麻烦。我们需要一个方式来帮助我们摆脱这个困境。匿名内部类则可以很好的解决这个问题。

我们使用匿名内部类

public static void main(String[] args) {
    Interface01 interface01 = new Interface01() {
        @Override
        public void show() {
            System.out.println("这里使用了匿名内部类");
        }
    };
    //调用接口方法
    interface01.show();
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

成功运行结果

    这里使用了匿名内部类

如何使用匿名内部类

基本格式

new 接口/类名(参数1, 参数2...){
    实现方法1(){
        
    }
    实现方法2(){
        
    }
    ......
};

    1
    2
    3
    4
    5
    6
    7
    8
    9

在上文的使用中，我们没有创建实现类就实现了具体的show方法。同时定义了接口的对象变量interface01。我们发现，这个变量和平常使用多态后的使用方式没有区别。

通常，我们也习惯用这样的方式创建并启动线程

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("我是一个线程");
    }
}).start();

    1
    2
    3
    4
    5
    6

常见问题

    匿名内部类是怎么实现的

    在上文代码编译后，我们查看一下class文件的路径

BxrQZd.png

再反编译一下看看

BxsW1f.png

至此，我们可以得知，匿名内部类在编译期间，会生成一个名称以$编号结尾的class文件，即它被识别为一个真实的类，仅在编译前（java文件）为匿名的形态。

    匿名内部类只可以使用在接口上吗

    不是的。匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求。

    举例说明：设存在具体类Class01，抽象类AbstractClass01，接口Interface01

    //具体类
    public class Class01 {
        public void show(String s){
            System.out.println("啦啦啦");
        }
    }
        1
        2
        3
        4
        5
        6

    //抽象类
    public abstract class AbstractClass01 {
        abstract void show(String s);
    }
        1
        2
        3
        4

    //接口
    public interface Interface01 {
        void show(String s);
    }
        1
        2
        3
        4

    测试类TestInner

    public class TestInner {
        public static void main(String[] args) {
            
            //重写具体类的方法
            new Class01(){
                @Override
                public void show(String s) {
                    System.out.println("我是一个" + s);
                }
            }.show("具体类");

            //重写抽象类的抽象方法
            new AbstractClass01(){
                @Override
                void show(String s) {
                    System.out.println("我是一个" + s);
                }
            }.show("抽象类");

            //实现接口的抽象方法
            new Interface01(){
                @Override
                public void show(String s) {
                    System.out.println("我是一个" + s);
                }
            }.show("接口");

        }
    }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30

    运行结果

        我是一个具体类
        我是一个抽象类
        我是一个接口
————————————————
版权声明：本文为CSDN博主「Weihaom_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/a850661962/article/details/109642780