匿名内部类、lambda匿名函数表达式

a、匿名内部类的定义格式：

  接口名称 对象名 = new 接口名称（）{
        //覆盖重写所有抽象方法
  }；

一、

  /**
   * lambda匿名函数的使用
   * Lambda省去面向对象的条条框框，格式由3个部分组成：
   *      1：一些参数
   *      2：一个箭头
   *      3：一段代码
   *
   *     Lambda表达式的标准格式为：
   *          (参数类型 参数名称) ‐> { 代码语句 }
   *
   *     格式说明：
   *      A:接口中抽象方法的参数列表,无参数则留空；多个参数则用逗号分隔
   *      B:-> 传递的意思,把参数传给方式体
   *      C:重写接口的抽象方法的方法体
   */

public class LambdaTest1 {
public static void main(String[] args) {
  /*
    //三个线程对应三个任务
    for (int i = 0; i <=2; i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();
    }
    */
  //使用lambda表达式，实现多线程
    new Thread(()->{
            System.out.println(Thread.currentThread().getName());
    }).start();
 }
 }

二、

public class LambdaTest2 {
public static void main(String[] args) {
    /**
     * 需求:     
     *      使用数组存储多个Person对象     
     *      对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
     */
    Persion[] arr={
            new Persion("古力娜扎",19),
            new Persion("迪丽热巴",18),
            new Persion("马尔扎哈",20),
    };
   /* 匿名内部类
         Comparator<Persion> com = new Comparator<Persion>() {
            @Override
            public int compare(Persion o1, Persion o2) {
            return o1.getAge() - o2.getAge();
            }
          };

         // 第二个参数为排序规则，即Comparator接口实例
         Arrays.sort(arr,com);
    */

    //lambda表达式的实现
    Arrays.sort(arr,(Persion o1, Persion o2)->{
        return o1.getAge() - o2.getAge();
    });

    for (Persion persion : arr) {
        System.out.println(persion);
    }
}
   }

三、

//自定义接口
public interface Calculator {
   int calc(int a, int b);
 }

public class LambdaTest3 {
public static void main(String[] args) {
    //匿名类
    /*
       invokeCalc(10, 20, new Calculator() {
        @Override
        public int calc(int a, int b) {
            return a + b;
        }
    });
    */

    //lambda
    invokeCalc(10,20,(int a,int b)->{
        return a + b;
    });
}

public static void invokeCalc(int a, int b, Calculator calculator){
    int result = calculator.calc(a, b);
    System.out.println("结果是："+result);
}
}

四、lambda表达式简洁版的条件：

  1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的 Runnable 、 
     Comparator 接口还是自定义的接口，只有当接口中的  抽象方法存在且唯一 时，才可以使用Lambda。 
  2. 使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

  实例：
    //lambda
    invokeCalc(10,20,( a, b)->
         a + b
    );

五、lembda的经典运用

  //正常实现方式
    List<ProductInfo> productInfoList = productService.findUpAll();

    List<Integer> categoryTypeList = new ArrayList<>()

    for(ProductInfo productInfo : productInfoList){

      categoryTypeList.add(productInfo.getCategoryType() )
    }


   //lambda表达式实现方式
   List<Integer> categoryTypeList = productInfoList.stream().map(e ->e.getCategoryType()).collect(Collectors.toList());

六、匿名内部类：是内部类的简化写法

        使用匿名内部类的前提条件：匿名内部类必须【继承】一个父类或者【实现】一个父接口。
       
        使用场景：在创建对象时，对象只是用一次

        格式：
             new 父类名或者接口名(){
                  // 方法重写
                  @Override
                  public void method() {
                      // 执行语句
                  }
              };    //逗号不能缺 
  
        使用匿名内部类目的可以简化：1. 定义子类
                                  2. 重写接口中的方法
                                  3. 创建子类对象
                                  4. 调用重写后的方法
                                  以上步骤最终只是为了调用方法


        例子：
              1、
                定义接口
                     public interface MyInterface {
                              void  method();
                     } 

                测试1
                   public class DemoTest {
                        public static void main(String[] args) {
                            MyInterface my = new MyInterface() {  
                                @Override
                                public void method() {
                                          System.out.println("匿名内部类...");
                                }
                           };
                            //将My传入shouMy方法中
                              shouMy(my);
                         }
                     public static void shouMy(MyInterface my){
                           my.method();
                        }
                    }


                测试2
                     public class DemoTest {
                        public static void main(String[] args) {
                            //将My传入shouMy方法中
                            shouMy(new MyInterface() {
                                @Override
                                public void method() {
                                    System.out.println("匿名内部类...");
                                }
                             });
                       }
                    public static void shouMy(MyInterface my){
                            my.method();
                        }
                  }