1.9 方法引用

冗余的Lambda场景

• 来看一个简单的函数式接口以应用Lambda表达式：

@FunctionalInterface
public interface Printable {
    void print(String str);
}

public class Demo01PrintSimple {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
 
    public static void main(String[] args) {
        printString(s ‐> System.out.println(s));//打印字符串
    }
}

• 这段代码的问题在于，对字符串进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是System.out
  对象中的println(String) 方法。既然Lambda希望做的事情就是调用println(String) 方法，那何必自己手动调
  用呢？

用方法引用改进代码

• 能否省去Lambda的语法格式（尽管它已经相当简洁）呢？只要“引用”过去就好了：

public class Demo02PrintRef {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
 
    public static void main(String[] args) {
        printString(System.out::println);//方法引用
    }
}

• 请注意其中的双冒号**:?* 写法，这被称为**“方法引用”**，而双冒号是一种新的语法。

方法引用符

• 如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

语义分析

• 例如上例中，System.out 对象中有一个重载的println(String) 方法恰好就是我们所需要的。那么对于printString 方法的函数式接口参数，对比下面两种写法，完全等效：
• Lambda表达式写法：s -> System.out.println(s);
• 方法引用写法：System.out::println
• 第一种语义是指：拿到参数之后经Lambda之手，继而传递给System.out.println 方法去处理。
• 第二种等效写法的语义是指：直接让System.out 中的println 方法来取代Lambda。两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。
• 注:**Lambda 中传递的参数一定是方法引用中的那个方法可以接收的类型,**否则会抛出异常

推导与省略

• 如果使用Lambda，那么根据**“可推导就是可省略”**的原则，无需指定参数类型，也无需指定的重载形式——它们都
  将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。

通过对象名引用成员方法

• 这是最常见的一种用法，与上例相同。如果一个类中已经存在了一个成员方法：

public class MethodRefObject {
    public void printUpperCase(String str) {
        System.out.println(str.toUpperCase());
    }
}

• 函数式接口仍然定义为：

@FunctionalInterface
public interface Printable {
    void print(String str);
}

• 那么当需要使用这个printUpperCase 成员方法来替代Printable 接口的Lambda的时候，已经具有了
  MethodRefObject 类的对象实例，则可以通过对象名引用成员方法，代码为：

public class Demo04MethodRef {
    private static void printString(Printable lambda) {
        lambda.print("Hello");
    }
 
    public static void main(String[] args) {
        MethodRefObject obj = new MethodRefObject();
        printString(obj::printUpperCase);
    }
}

通过类名称引用静态方法

• 由于在java.lang.Math 类中已经存在了静态方法abs ，所以当我们需要通过Lambda来调用该方法时，有两种写
  法。首先是函数式接口：

@FunctionalInterface
public interface Calcable {
    int calc(int num);
}

• 第一种写法是使用Lambda表达式：

public class Demo05Lambda {
    private static void method(int num, Calcable lambda) {
        System.out.println(lambda.calc(num));
    }
 
    public static void main(String[] args) {
        method(‐10, n ‐> Math.abs(n));
    }
}

• 但是使用方法引用的更好写法是：

public class Demo06MethodRef {
    private static void method(int num, Calcable lambda) {
        System.out.println(lambda.calc(num));
    }
 
    public static void main(String[] args) {
        method(‐10, Math::abs);
    }
}

通过super引用成员方法

• 如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。首先是函数式接口：

@FunctionalInterface
public interface Greetable {
    void greet();
}

• 然后是父类Human 的内容：

public class Human {
    public void sayHello() {
        System.out.println("Hello!");
    }
}

• 最后是子类Man 的内容，其中使用了Lambda的写法：

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
    }
 
    //定义方法method,参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
 
    public void show(){
        //调用method方法,使用Lambda表达式
        method(()‐>{
            //创建Human对象,调用sayHello方法
            new Human().sayHello();
        });
        //简化Lambda
        method(()‐>new Human().sayHello());
        //使用super关键字代替父类对象
        method(()‐>super.sayHello());
    }
}

• 但是如果使用方法引用来调用父类中的sayHello 方法会更好，例如另一个子类Woman ：

Public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
    }
 
    //定义方法method,参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
 
    public void show(){
        method(super::sayHello);
    }
}

通过this引用成员方法

• this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用**“this::成员方法”**的格式来使用方
  法引用。首先是简单的函数式接口：

@FunctionalInterface
public interface Richable {
    void buy();
}

• 下面是一个丈夫Husband 类：

public class Husband {
    private void buyHouse() {
        System.out.println("买套房子");
    }
 
    private void marry(Richable lambda) {
        lambda.buy();
    }
 
    public void beHappy() {
        marry(() ‐> this.buyHouse());
    }
}

• 如果希望取消掉Lambda表达式，用方法引用进行替换，则更好的写法为：

public class Husband {
    private void buyHouse() {
        System.out.println("买套房子");
    }
 
    private void marry(Richable lambda) {
        lambda.buy();
    }
 
    public void beHappy() {
        marry(this::buyHouse);
    }
}

类的构造器引用

• 由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用类名称::new 的格式表示。首先是一个简单的Person 类：

public class Person {
    private String name;
 
    public Person(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

• 然后是用来创建Person 对象的函数式接口：

public interface PersonBuilder {
    Person buildPerson(String name);
}

• 要使用这个函数式接口，可以通过Lambda表达式：

public class Demo09Lambda {
    public static void printName(String name, PersonBuilder builder) {
        System.out.println(builder.buildPerson(name).getName());
    }
 
    public static void main(String[] args) {
        printName("赵丽颖", name ‐> new Person(name));
    }
}

• 但是通过构造器引用，有更好的写法：

Public class Demo10ConstructorRef {
    public static void printName(String name, PersonBuilder builder) {
        System.out.println(builder.buildPerson(name).getName());
    }
 
    public static void main(String[] args) {
        printName("赵丽颖", Person::new);
    }
}

数组的构造器引用

• 数组也是Object 的子类对象，所以同样具有构造器，只是语法稍有不同。如果对应到Lambda的使用场景中时，
  需要一个函数式接口：

@FunctionalInterface
public interface ArrayBuilder {
    int[] buildArray(int length);
}

• 在应用该接口的时候，可以通过Lambda表达式：

Public class Demo11ArrayInitRef {   
    private static int[] initArray(int length, ArrayBuilder builder) {
        return builder.buildArray(length);
    }
 
    public static void main(String[] args) {
        int[] array = initArray(10, length ‐> new int[length]);
    }
}

• 但是更好的写法是使用数组的构造器引用：

public class Demo12ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) {
        return builder.buildArray(length);
    }
 
    public static void main(String[] args) {
        int[] array = initArray(10, int[]::new);
    }
}