匿名内部类

匿名内部类走一波

---

匿名内部类，听一下名称就知道它很惨，没有名字（引用数据类型）
但就是因为这样他可以更加节省空间，不需要名称，也可以很好的解决我们的需求，可
以作为方法的参数直接使用，在jdk1.8 以后可以很好的用lambdas表达式来实现替代，
就让我们在代码中来看一下怎么使用吧！

/**
 * Abstract抽象类
 */
abstract class AbstractTypeA {
    abstract public void testA();
}

/**
 * 自定义类继承一个Abstract修饰的类，需要完成在abstract类内的所有abstract方法
 */
class WuYun extends AbstractTypeA {
    @Override
    public void testA() {
        System.out.println("继承Abstract类，实现类内的abstract方法");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        WuYun wuYun = new WuYun();
        wuYun.testA();

        /*
        使用抽象类的引用指向一个匿名内部类的对象
        在当前大括号内，是一个类，继承abstract修饰的类，必须完成的代码
        也就是一个【类的本体】，但是当前这个大括号没有对应的类名，所以是
        一个匿名内部类，这里借助抽象类的名字，来创建一个【继承】于抽象类
        的子类对象，也就是
        【匿名内部类对象】
         */
        AbstractTypeA a = new AbstractTypeA() {
            @Override
            public void testA() {
                System.out.println("抽象类的匿名内部类对象，地址保存在父类抽象类的引用变量中");
            }
        };

        a.testA();

        /*
        匿名内部类的匿名对象，直接调用方法
        Android开发中很常见
         */
        new AbstractTypeA() {
            @Override
            public void testA() {
                System.out.println("抽象类的匿名内部类的匿名对象，直接调用方法");
            }
        }.testA();


        test(wuYun);

        /*
        匿名内部类的匿名对象，直接作为方法的参数
        【常用】
            1. 快
            2. 节约资源
         */
        test(new AbstractTypeA() {
            @Override
            public void testA() {
                System.out.println("匿名内部类的匿名对象，直接作为方法的参数！！！");
            }
        });
    }

    public static void test(AbstractTypeA a) {
        a.testA();
    }
}

接口的匿名内部类

interface A {
    public void testB();
}

class TypeA implements A {

    @Override
    public void testB() {
        System.out.println("自定义类遵从接口，实现接口中缺省属性为abstract的方法");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        TypeA typeA = new TypeA();
        typeA.testB();

        /*
        这里是把创建的接口匿名内部类的地址，赋值给了一个接口的引用
         */
        A a = new A() {
            @Override
            public void testB() {
                System.out.println("接口的匿名内部类对象");
            }
        };

        a.testB();

        /*
        匿名内部类的匿名对象
         */
        new A() {
            @Override
            public void testB() {
                System.out.println("匿名内部类的匿名对象，直接调用方法");
            }
        }.testB();

        /*
        匿名内部类的匿名对象，直接作为方法的参数
         */
        test(new A() {
            @Override
            public void testB() {
                System.out.println("接口A的匿名内部类的匿名对象，直接作为方法的参数");
            }
        });
    }

    public static void test(A a) {
        a.testB();
    }
}