方法引用（Method References）是一种语法糖，它本质上就是 Lambda 表达式，我们知道Lambda表达式是函数式接口的实例，所以说方法引用也是函数式接口的实例。

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

语法

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

  1. 类或对象 :: 方法名

eg

  1. public class ConsumerMethodReference {
  2.     public static void main(String[] args) {
  3.         Consumer<String> c = s -> System.out.println(s);
  4.         c.accept("Hello World");
  6.         Consumer<String> consumer = System.out::println;
  7.         consumer.accept("Hello World");
  8.     }
  9. }

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

方法引用的分类

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

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

  4. 类 :: new：构造方法引用。

    对象引用实例方法

    1. public class ConsumerMethodReference {
    2.  public static void main(String[] args) {
    4.      Consumer<String> consumer = System.out::println;
    5.      consumer.accept("Hello World");
    7.  }
    8. }

    类引用静态方法

    1. public class ComparatorMethodReference {
    2.  public static void main(String[] args) {
    3.      // Lambda 表达式
    4.      Comparator<Integer> l = (t1, t2) -> Integer.compare(t1, t2);
    5.      System.out.println(l.compare(1, 2));
    7.      // 类 :: 静态方法（ compare() 为静态方法）
    8.      Comparator<Integer> m = Integer::compare;
    9.      System.out.println(m.compare(3, 2));
    10.  }
    11. }

    类引用实例方法

    类引用构造方法

    ```java class Student { private String name;

    public Student() {

    1.  System.out.println("Student无参数构造方法");

    }

    public Student(String name) {

    1.  System.out.println("Student单参数构造方法");
    2.  this.name = name;

    }

    public String getName() {

    1.  return name;

    }

    public void setName(String name) {

    1.  this.name = name;

    }

}

public class StructMethodReference { public static void main(String[] args) { // 使用 Lambda 表达式，调用无参构造方法 Supplier a = () -> new Student(); a.get();

  1.     // 使用方法引用，引用无参构造方法
  2.     Supplier<Student> b = Student::new;
  3.     b.get();
  5.     // 使用 Lambda 表达式，调用单参构造方法
  6.     Function<String, Student> c = name -> new Student(name);
  7.     Student s1 = c.apply("c");
  8.     System.out.println(s1.getName());
  10.     // 使用方法引用，引用单参构造方法
  11.     Function<String, Student> d = Student::new;
  12.     Student s2 = d.apply("d");
  13.     System.out.println(s2.getName());
  14. }

} ```