通过前两个小节对Lambda表达式的学习，本小节我们来介绍一个更加深入的知识点 —— 方法引用。通过本小节的学习，你将了解到什么是方法引用，方法引用的基础语法，方法引用的使用条件和使用场景，方法引用的分类，方法引用的使用实例等内容。

1. 什么是方法引用

方法引用（Method References）是一种语法糖，它本质上就是 Lambda 表达式，我们知道Lambda表达式是函数式接口的实例，所以说方法引用也是函数式接口的实例。
Tips：什么是语法糖？语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。
可以将语法糖理解为汉语中的成语，用更简练的文字表达较复杂的含义。在得到广泛接受的情况下，可以提升交流的效率。
我们来回顾一个之前学过的实例：

  1. import java.util.function.Consumer;
  3. public class MethodReferencesDemo1 {
  5.     public static void main(String[] args) {
  6.         Consumer<String> consumer = s -> System.out.println(s);
  7.         consumer.accept("只消费，不返回");
  8.     }
  9. }

运行结果：

  1. 只消费，不返回

上例是 Java 内置函数式接口中的消费型接口，如果你使用idea编写代码，System.out.println(s)这个表达式可以一键替换为方法引用，将鼠标光标放置到语句上，会弹出提示框，再点击Replace lambda with method reference按钮即可完成一键替换，替换为方法引用后的实例代码：

  1. import java.util.function.Consumer;
  3. public class MethodReferencesDemo1 {
  5.     public static void main(String[] args) {
  6.         Consumer<String> consumer = System.out::println;
  7.         consumer.accept("只消费，不返回");
  8.     }
  9. }

我们看到System.out.println(s)这个表达式被替换成了System.out::println，同样成功执行了代码，看到这里，同学们脑袋上可能全是问号，这是什么语法？我们之前怎么没提过？别着急，我们马上就来讲解语法规则。

2. 语法

方法引用使用一对冒号（::）来引用方法，格式如下：

  1. 类或对象 :: 方法名

上面实例中方法引用的代码为：

  1. System.out::println

其中System.out就是PrintStream类的对象，println就是方法名。

3. 使用场景和使用条件

方法引用的使用场景为：当要传递给Lambda体的操作，已经有实现的方法了，就可以使用方法引用。
方法引用的使用条件为：接口中的抽象方法的形参列表和返回值类型与方法引用的方法形参列表和返回值相同。

4. 方法引用的分类

对于方法引用的使用，通常可以分为以下 4 种情况：

  1. 对象 :: 非静态方法：对象引用非静态方法，即实例方法；
  2. 类 :: 静态方法：类引用静态方法；
  3. 类 :: 非静态方法：类引用非静态方法；
  4. 类 :: new：构造方法引用。

下面我们根据以上几种情况来看几个实例。

4.1 对象引用实例方法

对象引用实例方法，我们已经在上面介绍过了，System.out就是对象，而println就是实例方法，这里不再赘述。

4.2 类引用静态方法

类引用静态方法，请查看以下实例：

  1. import java.util.Comparator;
  3. public class MethodReferencesDemo2 {
  5.     public static void main(String[] args) {
  6.         // 使用 Lambda 表达式
  7.         Comparator<Integer> comparator1 = (t1, t2) -> Integer.compare(t1, t2);
  8.         System.out.println(comparator1.compare(11, 12));
  10.         // 使用方法引用，类 :: 静态方法（ compare() 为静态方法）
  11.         Comparator<Integer> comparator2 = Integer::compare;
  12.         System.out.println(comparator2.compare(12, 11));
  13.     }
  14. }

运行结果：

  1. -1
  2. 1

查看 Java 源码，可观察到compare()方法是静态方法。
我们再来看一个实例：

  1. import java.util.Comparator;
  2. import java.util.function.Function;
  4. public class MethodReferencesDemo3 {
  6.     public static void main(String[] args) {
  7.         // 使用 Lambda 表达式
  8.         Function<Double, Long> function1 = d -> Math.round(d);
  9.         Long apply1 = function1.apply(1.0);
  10.         System.out.println(apply1);
  12.         // 使用方法引用，类 :: 静态方法（ round() 为静态方法）
  13.         Function<Double, Long> function2 = Math::round;
  14.         Long apply2 = function2.apply(2.0);
  15.         System.out.println(apply2);
  16.     }
  18. }

运行结果：

  1. 1
  2. 2

4.3 类引用实例方法

类引用实例方法，比较难以理解，请查看以下实例：

  1. import java.util.Comparator;
  3. public class MethodReferencesDemo4 {
  5.     public static void main(String[] args) {
  6.         // 使用 Lambda 表达式
  7.         Comparator<String> comparator1 = (s1, s2) -> s1.compareTo(s2);
  8.         int compare1 = comparator1.compare("Hello", "Java");
  9.         System.out.println(compare1);
  11.         // 使用方法引用，类 :: 实例方法（ compareTo() 为实例方法）
  12.         Comparator<String> comparator2 = String::compareTo;
  13.         int compare2 = comparator2.compare("Hello", "Hello");
  14.         System.out.println(compare2);
  15.     }
  17. }

运行结果：

  1. -2
  2. 0

Comparator接口中的compare(T t1, T t2)抽象方法，有两个参数，但是String类下的实例方法compareTo(String anotherString)只有 1 个参数，为什么这种情况下还能使用方法引用呢？这属于一个特殊情况，当函数式接口中的抽象方法有两个参数时，已实现方法的第 1 个参数作为方法调用者时，也可以使用方法引用。此时，就可以使用类来引用实例方法了（即实例中的String::compareTo）。

4.4 类引用构造方法

类引用构造方法，可以直接使用类名 :: new，请查看如下实例：

  1. import java.util.function.Function;
  2. import java.util.function.Supplier;
  4. public class MethodReferencesDemo5 {
  6.     static class Person {
  7.         private String name;
  9.         public Person() {
  10.             System.out.println("无参数构造方法执行了");
  11.         }
  13.         public Person(String name) {
  14.             System.out.println("单参数构造方法执行了");
  15.             this.name = name;
  16.         }
  18.         public String getName() {
  19.             return name;
  20.         }
  22.         public void setName(String name) {
  23.             this.name = name;
  24.         }
  26.     }
  28.     public static void main(String[] args) {
  30.         // 使用 Lambda 表达式，调用无参构造方法
  31.         Supplier<Person> supplier1 = () -> new Person();
  32.         supplier1.get();
  34.         // 使用方法引用，引用无参构造方法
  35.         Supplier<Person> supplier2 = Person::new;
  36.         supplier2.get();
  38.         // 使用 Lambda 表达式，调用单参构造方法
  39.         Function<String, Person> function1 = name -> new Person(name);
  40.         Person person1 = function1.apply("小慕");
  41.         System.out.println(person1.getName());
  44.         // 使用方法引用，引用单参构造方法
  45.         Function<String, Person> function2 = Person::new;
  46.         Person person2 = function1.apply("小明");
  47.         System.out.println(person2.getName());
  48.     }
  50. }

运行结果：

  1. 无参数构造方法执行了
  2. 无参数构造方法执行了
  3. 单参数构造方法执行了
  4. 小慕
  5. 单参数构造方法执行了
  6. 小明

在实例中，我们使用了Lambda表达式和方法引用两种方式，分别调用了静态内部类Person的无参和单参构造方法。函数式接口中的抽象方法的形参列表与构造方法的形参列表一致，抽象方法的返回值类型就是构造方法所属的类型。

5. 小结

通过本小节的学习，我们知道了方法引用是一个语法糖，它本质上还是Lambda表达式。方法引用使用一对冒号（::）来引用方法。要传递给Lambda体的操作，已经有实现的方法了，就可以使用方法引用；想要使用方法引用，就要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法形参列表和返回值相同。方法引用可能较为抽象，希望同学们课下多加练习。