匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名。

• 本质是一个类
• 内部类
• 该类没有名字
• 同时还是一个对象

1. 匿名内部类的基本语法

   new 类或接口（参数列表）{ 类体 }；

基于接口的匿名内部类

package test;
/**
 * 演示匿名内部类的使用
 */
public class Main {//外部其他类
    public static void main(String[] args) {
        Outer Outer = new Outer();
        Outer.method();
    }
}
class Outer { //外部类
    private int n1 = 10;//属性
    public void method() {//方法
        //1.需求： 想使用IA接口,并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象
        //3.这里需求是 Tiger/Dog 类只是使用一次，后面再不使用
        //4. 可以使用匿名内部类来简化开发
        //5. tiger的编译类型 ? IA(接口)
        //6. tiger的运行类型 ? 就是匿名内部类  Outer$1
        /*
            我们看底层 会分配 类名 Outer$1(系统自动分配)
            class Outer$1 implements IA {
                @Override
                public void cry() {
                    System.out.println("老虎叫唤...");
                }
            }
         */
        //传统方式
//        IA tiger = new Tiger();
//        tiger.cry();
        //7. jdk底层在创建匿名内部类 Outer$1,立即马上就创建了 Outer$1实例，
        //   并且把地址返回给 tiger
        //8. 匿名内部类使用一次，就不能再使用
        //基于接口的匿名内部类
        IA tiger = new IA(){//tiger接收之后可以反复调用
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();
    }
}
interface IA {//接口
    public void cry();
}
//传统写法
//class Tiger implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("老虎叫唤...");
//    }
//}
//class Dog implements  IA{
//    @Override
//    public void cry() {
//        System.out.println("小狗汪汪...");
//    }
//}

基于类的匿名内部类

package test;
/**
 * 演示匿名内部类的使用
 */
public class Main {//外部其他类
    public static void main(String[] args) {
        Outer Outer = new Outer();
        Outer.method();
    }
}
class Outer { //外部类
    private int n1 = 10;//属性
    public void method() {//方法
        //分析
        //1. father编译类型 Father
        //2. father运行类型 Outer$1
        //3. 底层会创建匿名内部类
        /*
            class Outer$1 extends Father{
                @Override
                public void test() {
                    System.out.println("匿名内部类重写了test方法");
                }
            }
         */
        //4. 同时也直接返回了 匿名内部类 Outer$1的对象
        //5. 注意("WTY2002") 参数列表会传递给 构造器
        //基于类的匿名内部类
        Father father = new Father("WTY2002"){
            //可以选择性的重写test方法
            //因为Father不是抽象类
            @Override
            public void test(){
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());//Outer$1
        father.test();
        //基于抽象类的匿名内部类
        Animal animal = new Animal(){
            //此处必须实现抽象方法
            @Override
            void eat() {
                System.out.println("小狗吃骨头...（匿名内部类重写了抽象类中的方法）");
            }
        };
        animal.eat();
    }
}
class Father {//类
    public Father(String name) {//构造器
        System.out.println("接收到name=" + name);
    }
    public void test() {//方法
    }
}
abstract class Animal { //抽象类
    abstract void eat();
}