Java中的Lambda表达式（part3）

六、语法进阶

一、方法引用（静态方法和普通方法）

一、why

在实际应用过程中，一个接口在很多地方都会调用同一个实现，比如：

        LambdaSingleReturnMutipleParmeter lambda11 = (a,b)->a+b;
        LambdaSingleReturnMutipleParmeter lambda12 = (a,b)->a*b;

这样一来每次都要写上具体的实现方法，如果需求变更，则每一处都需要更改，基于这种情况，可以将后续的实现更改为自定义的方法，需要时直接调用即可

二、what

方法引用：

可以可快速的将一个lambda表达式的实现指向一个已经实现的方法

方法的隶属者：如果是静态方法，隶属者就是一个类，其他的话都是隶属对象

语法：方法的隶属者::方法名

注意：

• 引用的方法中，参数的个数和类型一定要和接口中定义的方法一致
• 返回值的类型也一定要和接口中的方法一致

三、how

• 静态方法

  public class Demo{
      public static void main(String[] args) {
          // 精简前
          LambdaSingleReturnMutipleParmeter lambda1 = (a,b)->a+b;
          LambdaSingleReturnMutipleParmeter lambda2 = (a,b)->a*b;
  
          // 精简后
          LambdaSingleReturnMutipleParmeter lambda3 = (a,b)->MyStaticClass.add(a,b);
          LambdaSingleReturnMutipleParmeter lambda4 = MyStaticClass::multiplication;
          System.out.println(lambda1.test(10,20));
          System.out.println(lambda2.test(10,20));
          System.out.println(lambda3.test(10,20));
          System.out.println(lambda4.test(10,20));
      }
  }
  
  // 静态方法类
  class MyStaticClass {
      public static int add(int x,int y){
          return x+y;
      }
      public static int multiplication(int x,int y){
          return x*y;
      }
  }
  
  @FunctionalInterface
  interface LambdaSingleReturnMutipleParmeter{
      int test(int a, int b);
  }
  

• 非静态普通方法

  /**
   *  有返回值 有多个参数的接口
   */
  @FunctionalInterface
  interface LambdaSingleReturnMutipleparmeter{
      int test(int a, int b);
  }
  
  // 自定义非静态类
  class MyNotStaticClass{
      public int add(int x, int y){
          return x + y;
      }
      public int multiplication(int x, int y){
          return x * y;
      }
  }
  
  public class Demo{
      public static void main(String[] args) {
          // 精简前
          LambdaSingleReturnMutipleparmeter lambda1 = (a,b)->a+b;
          LambdaSingleReturnMutipleparmeter lambda2 = (a,b)->a*b;
  
          // 精简后
          MyNotStaticClass myNotStaticClassObj = new MyNotStaticClass();
          LambdaSingleReturnMutipleparmeter lambda3 = (a,b)->myNotStaticClassObj.add(a,b);
          LambdaSingleReturnMutipleparmeter lambda4 = myNotStaticClassObj::multiplication;
          
          System.out.println(lambda3.test(10,20));
          System.out.println(lambda4.test(10,20));
      }
  }
  

二、方法引用-构造方法

/**
 *  两个接口，各有一个方法，一个接口的方法需要引用person的无参构造，
 *  一个接口的方法需要引用Person的有参数构造，用于返回两个Person对象
 */

// pojo类
class Person{
    public String name;
    public int age;

    public Person(){
        System.out.println("Person的无参构造方法执行");
    }

    public Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("Person的有参构造方法执行");
    }
}

// 两个接口
interface PersonCreater{
    // 通过Person的无参构造实现
    Person getPerson();
}

interface PersonCreater2{
    // 通过Person的有参构造实现
    Person getPerson(String name,int age);
}

public class Demo{
    public static void main(String[] args) {
        // 需求1：调用无参数的构造方法
        // 方式一：
        PersonCreater personCreater11 = ()->new Person();
        Person person = personCreater11.getPerson();

        // 方式二：
        PersonCreater personCreater12 = Person::new;
        Person person2 = personCreater12.getPerson();

        // 需求2：调用有参数的构造方法
        // 方法一
        PersonCreater2 personCreater21 = (a,b)->new Person(a,b);
        Person person3 = personCreater21.getPerson("张三",13);

        // 方法二
        PersonCreater2 personCreater22 = Person::new;
        Person person4 = personCreater22.getPerson("李四",14);
    }
}