方法引用

1. 体验方法引用

在使用 Lambda 表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作。

那么考虑一种情况：如果我们在 Lambda 中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？

答案肯定是没有必要，那我们又是如何使用已经存在的方案的呢？

这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案。

练习

需求：

• 定义一个接口(Printable)，里面定义一个抽象方法：void printString(String s);
• 定义一个测试类(PrintableDemo)，在测试类中提供两个方法
  • 一个方法是：usePrintable(Printable p)
  • 一个方法是主方法，在主方法中调用 usePrintable 方法

实现：

1. Printable 接口

   public interface Printable { 
       void printString(String s); 
   }
   

2. 测试类

   public class PrintableDemo { 
       public static void main(String[] args) { 
           //在主方法中调用usePrintable方法 
           usePrintable((String s) -> { 
               System.out.println(s);  
           }); 
           //Lambda简化写法 
           usePrintable(s -> System.out.println(s)); 
           //方法引用 
           usePrintable(System.out::println); 
       }
       private static void usePrintable(Printable p) { 
           p.printString("爱生活爱Java"); 
       } 
   }
   

3. 运行结果

   爱生活爱Java
   爱生活爱Java
   爱生活爱Java
   

2. 方法引用符

方法引用符

• :: 该符号为引用运算符，而它所在的表达式被称为方法引用

回顾一下我们在体验方法引用中的代码

• Lambda 表达式：

  usePrintable(s -> System.out.println(s));
  

  分析：拿到参数 s 之后通过 Lambda 表达式，传递给 System.out.println 方法去处理

• 方法引用：

  usePrintable(System.out::println);
  

  分析：直接使用 System.out 中的 println 方法来取代 Lambda，代码更加的简洁

推导与省略

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

3. Lambda 表达式支持的方法引用

常见的引用方式：

• 引用类方法
• 引用对象的实例方法
• 引用类的实例方法
• 引用构造器

4. 引用类方法

引用类方法，其实就是引用类的静态方法

• 格式：

  类名::静态方法
  

• 范例：

  Integer::parseInt
  

  Integer 类的方法：public static int parseInt(String s) 将此 String 转换为 int 类型数据

• 使用说明：Lambda 表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

练习

需求：

• 定义一个接口(Converter)，里面定义一个抽象方法

  int convert(String s);
  

• 定义一个测试类(ConverterDemo)，在测试类中提供两个方法

  • 一个方法是：useConverter(Converter c)
  • 一个方法是主方法，在主方法中调用 useConverter 方法

实现：

1. Converter 接口

   public interface Converter {
       int convert(String s);
   }
   

2. 测试类

   public class ConverterDemo {
       public static int useConverter(Converter c) {
           return c.convert("666");
       }
   
       public static void main(String[] args) {
           // 匿名类
           int num1 = useConverter(new Converter() {
               @Override
               public int convert(String s) {
                   return Integer.parseInt(s);
               }
           });
   
           // Lambda
           int num2 = useConverter(s -> Integer.parseInt(s));
   
           // 引用类方法
           int num3 = useConverter(Integer::parseInt);
   
           System.out.println(num1);
           System.out.println(num2);
           System.out.println(num3);
   
       }
   }
   

3. 运行结果

   666
   666
   666
   

5. 引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

• 格式：

  对象::成员方法
  

• 范例：

  "HelloWorld"::toUpperCase
  

  String 类中的方法：public String toUpperCase() 将此 String 所有字符转换为大写

练习

需求：

• 定义一个类(PrintString)，里面定义一个方法

  // 把字符串参数变成大写的数据，然后在控制台输出
  public void printUpper(String s)
  

• 定义一个接口(Printer)，里面定义一个抽象方法

  void printUpperCase(String s)
  

• 定义一个测试类(PrinterDemo)，在测试类中提供两个方法

  • 一个方法是：usePrinter(Printer p)
  • 一个方法是主方法，在主方法中调用 usePrinter 方法

实现：

1. PrintString 类

   public class PrintString {
       // 把字符串参数变成大写的数据，然后在控制台输出
       public void printUpper(String s) {
           System.out.println(s.toUpperCase());
       }
   }
   

2. Printer 接口

   public interface Printer {
       void printUpperCase(String s);
   }
   

3. 测试类

   public class PrinterDemo {
       public static void usePrinter(Printer p) {
           p.printUpperCase("HelloWorld");
       }
   
       public static void main(String[] args) {
           PrintString printString = new PrintString();
           // Lambda
           usePrinter(s-> printString.printUpper(s));
           // 引用对象的实例方法
           usePrinter(printString::printUpper);
       }
   }
   
   

4. 运行结果

   HELLOWORLD
   HELLOWORLD
   

6. 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

• 格式：

  类名::成员方法
  

• 范例：

  String::substring
  

  String 类中的方法： public String substring(int beginIndex,int endIndex)

  从 beginIndex 开始到 endIndex 结束，截取字符串。返回一个子串，子串的长度为 endIndex-beginIndex

• 使用说明

  Lambda 表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数

练习

需求：

• 定义一个接口(MyString)，里面定义一个抽象方法：

  String mySubString(String s,int x,int y);
  

• 定义一个测试类(MyStringDemo)，在测试类中提供两个方法

  • 一个方法是：useMyString(MyString myString)
  • 一个方法是主方法，在主方法中调用 useMyString 方法

实现：

1. MyString 接口

   public interface MyString {
       String mySubString(String s, int x, int y);
   }
   

2. 测试类

   public class MyStringDemo {
       public static void useMyString(MyString myString) {
           String mySubString = myString.mySubString("Hello", 0, 3);
           System.out.println(mySubString);
       }
   
       public static void main(String[] args) {
           // Lambda
           useMyString((s, x, y) -> s.substring(x, y));
           // 引用类的实例方法
           useMyString(String::substring);
       }
   }
   
   

3. 运行结果

   Hel
   Hel
   

7. 引用构造器

引用构造器，其实就是引用构造方法

• 格式：

  类名::new
  

• 范例：

  Student::new
  

• 使用说明

  Lambda 表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

练习

需求：

• 定义一个类(Student)，里面有两个成员变量(name，age)

  并提供无参构造方法和带参构造方法，以及成员变量对应的 get 和 set 方法

• 定义一个接口(StudentBuilder)，里面定义一个抽象方法

  Student build(String name,int age);
  

• 定义一个测试类(StudentDemo)，在测试类中提供两个方法

  • 一个方法是：useStudentBuilder(StudentBuilder s)
  • 一个方法是主方法，在主方法中调用 useStudentBuilder 方法

实现：

1. Student 类

   public class Student {
       private String name;
       private Integer age;
   
       public Student() {
       }
   
       public Student(String name, Integer age) {
           this.name = name;
           this.age = age;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public Integer getAge() {
           return age;
       }
   
       public void setAge(Integer age) {
           this.age = age;
       }
   }
   

2. StudentBuilder 接口

   public interface StudentBuilder {
       Student build(String name, Integer age);
   }
   

3. 测试类

   public class StudentDemo {
       public static void useStudentBuilder(StudentBuilder s) {
           Student student = s.build("张三", 20);
           System.out.println(student.getName() + " " + student.getAge());
       }
   
       public static void main(String[] args) {
           // Lambda
           useStudentBuilder((name, age) -> new Student(name, age));
           // 引用构造器
           useStudentBuilder(Student::new);
       }
   }
   
   

4. 运行结果

   张三 20
   张三 20