基于抽象类和接口的匿名内部类

匿名内部类

匿名内部类，就是没有名字的一种嵌]类。它是Java对类的定义方式之一。

目的：减少代码的书写量。

基于抽象类的匿名内部类：

package com.lyc.lesson;

abstract class Person4{
    abstract void eat();
}

public class Lesson06 {
    public static void main(String[] args) {
        //方式一
//        Person4 person4 =new Person4() {
//            @Override
//            void eat() {
//                System.out.println("吃饭");
//            }
//        };
//        person4.eat();
        
       //方式二
       new Person4() {
            @Override
            void eat() {
                System.out.println("吃饭");
            }
        };
    }
}

声明一个抽象类，按照一般情况我们是用一个普通类去继承抽象类，然后实现抽象类中的抽象方法。

然后我们使用匿名内部类的方法来书写代码，如上述代买所示，当我们有一个抽象类时，不在使用普通类继承它，而是直接创建抽象类对象，并根据报错提示(图1)，来创建匿名内部类。

一般的匿名内部类创建方式有两种，如上的方式一和方式二。

对于方式一，当我们抽象类中存在多个抽象方法时，我们可以通过类名多次调用。

而对于方法二，匿名内部类是一次性的，即一个匿名内部类只能那个调用一个方法。如下：

package com.lyc.lesson;

abstract class Animal{
    public abstract void call();
    public abstract void call1();
    
}
public class Lesson07 {
    public static void main(String[] args) {
        new Animal(){
            @Override
            public void call() {
                System.out.println("老鼠叫！！！");
            }

            @Override
            public void call1() {
                System.out.println("花猫叫");
            }
        }.call();
        
        new Animal(){
            @Override
            public void call() {
                System.out.println("老鼠叫！！！");
            }

            @Override
            public void call1() {
                System.out.println("花猫叫");
            }
        }.call1();
    }
}

基于接口的匿名抽象类：

基于接口的匿名抽象类与基于抽象类的匿名内部类使用方式几乎一样。

package com.lyc.lesson;

interface Person5{
    abstract void eat();
}

public class Lesson07 {
    public static void main(String[] args) {
//       Person5 person5 = new Person5() {
//            @Override
//            public void eat() {
//                System.out.println("吃饭");
//            }
//        };
//       person5.eat();

        new Person5() {
            @Override
            public void eat() {
                System.out.println("吃饭");
            }
        }.eat();
    }
}

而在真实开发的中，对匿名内部类的使用方式，一般是一个方法参数是一个接口对象，不用再新建一个类去实现这个接口，直接方法中去new 接口。

package com.lyc.lesson;

interface Person6{
    void eat();
}

public class Lesson08 {
    public static void main(String[] args) {
        test(new Person6() {
            @Override
            public void eat() {
                System.out.println("我要吃饭");
            }
        });
    }
    public static void test(Person6 person6){
        person6.eat();
    }
}