匿名内部类 面向对象

匿名内部类

匿名内部类
简化实现类|子类的,因为接口或者抽象类中可能纯在抽象方法,必须在实现类|子类中重写,可以通过匿名内部类简化实现类|子类

​ 创建一个匿名内部类的对象
​ new 接口名|抽象类名() {
​ 匿名内部类的类体;
​ }
​ 创建的就是当前这个接口的实现类|这个抽象类的子类 的对象

public class Outer06 {
    public static void main(String[] args) {
        //创建一个Smoke实现类的对象
        //Demo  d = new Demo();

        //new 一个叫做Smoke接口的实现类的对象,这个实现类没有类名,所有是匿名的,但是{}就是实现类的类体
        //1) 匿名对象: 只能在当前行使用一次
        new Smoke(){

            @Override
            public void smoking() {
                System.out.println("边吸烟边敲代码...");
            }
        }.smoking();

        //匿名内部类的匿名对象,只能在当前行使用一次
        new AbsDemo(){

            @Override
            void test() {
                System.out.println("抽象类的匿名子类");
            }

            @Override
            void test2() {

            }
        }.haha();

        //2.当前作用域中使用多次匿名内部类对象,通过接口类型的引用指向
        //接口多态   接口类型的引用指向实现类对象
        Smoke s = new Smoke(){

            @Override
            public void smoking() {
                System.out.println("边吸烟边游泳!!!!");
            }
        };

        s.smoking();
        s.smoking();
        s.smoking();

        //3.匿名内部类对象作为方法的参数
        testSmoke(new Smoke() {
            @Override
            public void smoking() {
                System.out.println("吸烟的时候什么都能做哈哈哈哈");
            }
        });
    }
    //只能接受有抽烟能力的
    static void testSmoke(Smoke s){
        s.smoking();
    }
}

//接口
interface Smoke{
    void smoking();
}

//实现类
//demo实现类作用: 就是为重写抽象方法,但是这个类demo没有自己本身的作用
class Demo implements Smoke{

    @Override
    public void smoking() {
        System.out.println("边吸烟边吐烟圈...");
    }
}

//抽象类
abstract class AbsDemo{
    abstract void test();
    abstract void test2();

    public void haha(){
        System.out.println("hahahahah");
    }
}