Javase学习09-匿名内部类

1. 什么是匿名内部类？

1.1 定义

匿名内部类就是没有名称的内部类

1.2 说明

在某一个类或者接口只有一个抽象方法时，如果我们不想去搞它的子类或者实现类 ，那么我们可以使用匿名内部类来实现它。

1.3 前提

1. 必须是类或者接口

2. 格式：

//相当于是一个子类实现类或接口的实现类
new 类名/接口名(){
    重写抽象方法
}

2. 使用方式

2.1 使用传统方式调用抽象类方法

public class Demo01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}
abstract class Animals {
    abstract void eat();
}
class Dog extends Animals{

    @Override
    void eat() {
        System.out.println("狗吃肉");
    }
}

结果：

狗吃肉

可见，该Animals抽象类只有一个抽象方法，并且只需要调用一次。如此写一个Dog实现类太麻烦且无意义。

这时，我们就可以使用匿名内部类来调用抽象类中的方法。

2.2 使用匿名内部类调用抽象类方法

public class Demo01 {
    public static void main(String[] args) {
        // 整体相当于Animals的子类对象
        new Animals() {
            @Override
            void eat() {
                System.out.println("狗吃肉");
            }
        };
        //
    }
}
abstract class Animals {
    abstract void eat();
}

使用匿名内部类来调用父类eat()方法有两种方式：

第1种：

new Animals() {
    @Override
    void eat() {
        System.out.println("狗吃肉");
    }
}.eat();

第2种：

//前面说过，该整体相当于是Animals抽象类的子类对象，父类调用子类对象，这就是多态的体现形式。
Animals a = new Animals() {
    @Override
    void eat() {
        System.out.println("狗吃肉");
    }
};
a.eat();

通过匿名内部类访问局部变量时，在JDK1.8版本之前必须要在局部变量前加final关键字，在该版本之后会自动添加，虽然不显示，但实际存在，无法对菊部变量重新赋值

String type = "二哈";
Animals a = new Animals() {
    @Override
    void eat() {
        System.out.println( type + "在吃肉");
    }
};
a.eat();

2.3 使用匿名内部类调用接口方法

public class Demo02{
    public static void main(String[] args) {
        new Inter(){
            @Override
            public void method() {
                System.out.println("method!!!");
            }
        }.method();
    }

}
interface Inter{
    void method();
}

2.4 匿名内部类的作用

作为方法参数的时候进行传递：

当一个方法需要调用接口中的方法时，需要传入一个接口的实现类。

按传统的方法需要写一个接口的实现类重写接口中的抽象方法，然后new一个实现类对象传入到方法中

/**
 * @author: TSCCG
 * @date: 2021/5/19
 */
public class Demo02{
    public static void main(String[] args) {
        Son son = new Son();
        function(son);
    }
    //function方法需要一个接口的实现类 Inter inter = new Inter();
    public static void function(Inter inter) {
        inter.method();
    }

}
class Son implements Inter {

    @Override
    public void method() {
        System.out.println("method!!!");
    }
}
interface Inter{
    void method();
}

这在接口中只有一个方法且只调用一次时过于麻烦，使用匿名内部类即可代替实现类

/**
 * @author: TSCCG
 * @date: 2021/5/19
 */
public class Demo02{
    public static void main(String[] args) {
        function(
                //匿名内部类相当于传递了一个实现类到function里
                new Inter() {
                    @Override
                    public void method() {
                        System.out.println("method!!!");
                    }
                }
        );
    }
    //function方法需要一个接口的实现类 Inter inter = new Inter();
    public static void function(Inter inter) {
        inter.method();
    }

}
interface Inter{
    void method();
}

原文地址：https://www.cnblogs.com/TSCCG/p/14787265.html