匿名内部类使用细节

● 本质是类
● 内部类
● 该类没有名字
● 同时还是一个对象
说明: 匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

基于接口的匿名内部类的使用

public class Anonymous {
    public static void main(String[] args) {
        
    }
}


class Outer04{ //外部类
    public int n1 = 10; //属性
    
    public void method() { //方法
        
    }
}

interface IA { //接口
    public void cry();
}


class Father{
    public Father(String name) { //构造器

    }

    public void test() { //方法

    }
}

需求: 想使用IA接口，并创建对象传统方式，写一个类，实现该接口，并创建对象

class Tiger implements IA{
    @Override
    public void cry() {
        System.out.println("老虎叫唤...");
    }
}

public class Anonymous {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();

    }
}


class Outer04{ //外部类
    public int n1 = 10; //属性

    //基于接口的匿名内部类
    //1.需求: 想使用IA接口，并创建对象
    //2.传统方式，写一个类，实现该接口，并创建对象
    public void method() { //方法
        IA tiger = new Tiger();
        tiger.cry();
    }
}

但是如果需求是Tiger类只使用一次，后面不再使用，可以使用匿名内部类简化开发

class Outer04 { //外部类
    public int n1 = 10; //属性
    public void method() { //方法
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        tiger.cry();
    }
}

可以达到一样的效果。

• 这里tiger的编译类型是IA ,运行类型是匿名内部类
• 这个匿名内部类其实就是XXX => Outer04$01
• JDK底层在创建匿名内部类Outer04$01，立即马上创建了Outer04$01实例，并且把地址返回给tiger
• 匿名内部类使用一次，就不能再使用

class XXX implements IA {
     @Override
     public void cry() {
          System.out.println("老虎叫唤...");
     }
 
}

基于类的匿名内部类的使用

  //1.father的编译类型是Father
        //2. father的运行类型是Outer04$02
        //3.底层会创建匿名内部类
        /*
        * class XXX extends Father {
        *   @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        * }
        * */
        Father father = new Father("jack"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());
        father.test();

基于抽象类的匿名内部类

abstract class Animal{
    abstract void eat();
}



      //基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void eat() {
                System.out.println("小狗吃骨头...");
            }
        };

使用细节

public class AnonymousInnerClassDetail {
   public static void main(String[] args) {
       Outer05 outer05 = new Outer05();
       outer05.f1();

   }
}

class Outer05{
   private int n1 = 99;

   public void f1() {
       //创建一个基于类的匿名内部类
       Person person = new Person() {
           @Override
           public void hi() {
               System.out.println("匿名内部类重写了hi方法");
           }
       };
       person.hi(); //动态绑定，运行类型是Outer05$01其实输出重写的hi方法
   }
}
class Person{ //类
   public void hi(){
       System.out.println("Person hi()");
   }

}

也可以直接调用

//也可以直接调用 匿名内部类本身也是返回对象
        new Person() {
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi方法");
            }
        }.hi();

可以直接访问外部类的所有成员，包括私有的

new Person() {
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi方法" + n1);
            }
        }.hi();

不能添加访问修饰符，因为它的地位就是一个局部变量

作用域：仅仅在定义它的方法或代码块中

匿名内部类—>访问----->外部类成员 直接访问

外部其他类------不能访问---->匿名内部类

如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

最佳实践

public class InnerClassExercise01 {
    public static void main(String[] args) {

        //当做实参直接传递，简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是show方法");
            }
        });

        //传统方法需要再定义一个类实现接口 再去调用
    }

    //静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}

//接口
interface IL{
    void show();
}

有一个铃声Bell，里面有个ring方法 有一个手机类CellPhone，具有闹钟功能alarmClock，参数是Bell类型
测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印:懒猪起床了 再传入另一个匿名内部类(对象)，打印:小伙伴上课了

public interface Bell {
    void ring();
}

public class Cellphone {
    public void alarmClock(Bell bell) {
        bell.ring();
    }
}

public class TestRing {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });

        cellphone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了...");
            }
        });


    }
}