当做实参传递，简洁高效

  1. package test;
  3. public class Main {
  4.     public static void main(String[] args) {
  6.         //当做实参直接传递，简洁高效
  7.         f1(new IL() {//一次使用
  8.             @Override
  9.             public void show() {
  10.                 System.out.println("这是一副名画~~...");
  11.             }
  12.         });
  13.         //传统方法 =>需要专门写一个类
  14.         f1(new Picture());
  15.     }
  17.     //静态方法,形参是接口类型
  18.     public static void f1(IL il) {
  19.         il.show();
  20.     }
  21. }
  22. //接口
  23. interface IL {
  24.     void show();
  25. }
  27. //类->实现IL => 编程领域 (硬编码)
  28. class Picture implements IL {
  30.     @Override
  31.     public void show() {
  32.         System.out.println("这是一副名画XX...");
  33.     }
  34. }

image.png

案例二

需求

  1. 有一个铃声接口Bell，里面有一个ring方法
  2. 有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型
  3. 测试手机类的闹钟功能，通过匿名内部类（对象）作为参数，打印：懒猪起床了！
  4. 再传入另一个匿名内部类（对象），打印：小伙伴上课了

    实现

    ```java package test;

public class Main { public static void main(String[] args) { / 1.有一个铃声接口Bell，里面有个ring方法。 2.有一个手机类Cellphone，具有闹钟功能alarmClock，参数是Bell类型 3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了 4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了 / CellPhone cellPhone = new CellPhone(); //1. 传递的是实现了 Bell接口的匿名内部类 Main$1 //2. 重写了 ring //3. Bell bell = new Bell() { // @Override // public void ring() { // System.out.println(“懒猪起床了”); // } // }

  1.     cellPhone.alarmClock(new Bell() {
  2.         @Override
  3.         public void ring() {
  4.             System.out.println("懒猪起床了");
  5.         }
  6.     });
  8.     cellPhone.alarmClock(new Bell() {
  9.         @Override
  10.         public void ring() {
  11.             System.out.println("小伙伴上课了");
  12.         }
  13.     });
  14. }

} interface Bell{ //接口 void ring();//方法 } class CellPhone{//类 public void alarmClock(Bell bell){//形参是Bell接口类型 System.out.println(bell.getClass()); bell.ring();//动态绑定 } } ``` image.png