什么是方法引用呢，我们先看一个例子（了解这个之前，得先了解Lambda表达式，不清楚Lambda表达式的可以看这个）
Interface1：接口1，里面有一个抽象方法mathod
Demo：测试类，体验方法引用
Interface1：接口1的代码
package com.testMethodReference;
/**
* @author 林高禄
* @create 2020-06-03-9:33
*/
public interface Interface {
int method(int a,int b);
}
Demo：测试类代码
package com.testMethodReference;
/**
* @author 林高禄
* @create 2020-06-03-9:34
*/
public class Demo {
public static void main(String[] args) {
// Lambda表达式
// 提示，Lambda can be replaced with method reference more... (Ctrl+F1)，Lambda表达式可用方法引用代替
useInterface((a,b)-> Math.max(a,b));
// 方法引用
useInterface(Math::max);
}
private static void useInterface(Interface i){
int method = i.method(3, 5);
System.out.println(method);
}
}
运行测试Demo,输出：
5
5
方法引用符::
- ::该符号为引用运算符，而它所在的表达式被称为方法引用
- 方法的引用基于Lambda表达式
推导与省略
- 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定重载形式，它们都将被自动推导
- 如果使用方法引用，可是可以根据上下文进行推导的
- 方法引用就是Lambda表达式的孪生兄弟
方法引用常见的引用方式：
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器：格式：类名::new
代码，为了方便，所有的类都写在了一个文件
- Demo2：测试类
- Converter：测试引用类方法的接口
- Interface1：测试引用对象的实例方法的接口
- MyClass：测试引用对象的实例方法的类
- Interface2：测试引用类的实例方法的接口
- Interface3：测试引用类的实例方法的接口
- StudentInterface：测试引用构造器的接口
- Student：测试引用构造器的类
package com.testMethodReference;
/**
* @author 林高禄
* @create 2020-06-03-10:00
*/
public class Demo2 {
public static void main(String[] args) {
System.out.println("-----引用类方法-----");
// Lambda表达式
useConverter(s->Integer.parseInt(s));
// 方法引用--引用类方法
// Lambda表达式被类的方法替代的时候,它的形式参数全部传递给静态方法作为参数
useConverter(Integer::parseInt);
System.out.println("-----引用对象的实例方法-----");
// Lambda表达式
useInterface1(s-> System.out.println(s.toUpperCase()));
// 方法引用--引用对象的实例方法
// Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数
MyClass my = new MyClass();
useInterface1(my::printUpper);
System.out.println("-----引用类的实例方法-----");
// Lambda表达式
useInterface2((x,s,y)->s.substring(x,y));
// 方法引用--引用类的实例方法
// 报错，Cannot resolve method 'substring'，无法解析方法“substring”
//useInterface2(String::substring);
// Lambda表达式
useInterface3((s,x,y)->s.substring(x,y));
// 方法引用--引用类的实例方法
// Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数
useInterface3(String::substring);
System.out.println("-----引用构造器-----");
// Lambda表达式
useStudentInterface((name,age)->new Student(name,age));
// 方法引用--引用构造器
// Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
useStudentInterface(Student::new);
}
private static void useConverter(Converter c){
int convert = c.convert("110");
System.out.println(convert);
}
private static void useInterface1(Interface1 i){
i.printUpper("LinGaoLu");
}
private static void useInterface2(Interface2 i){
String s = i.mySubString(3,"LinGaoLu",6);
System.out.println(s);
}
private static void useInterface3(Interface3 i){
String s = i.mySubString("LinGaoLu",3,6);
System.out.println(s);
}
private static void useStudentInterface(StudentInterface s){
Student student = s.studentBuild("林高禄", 27);
System.out.println(student.toString());
}
}
interface Converter{
int convert(String s);
}
class MyClass{
public void printUpper(String s){
System.out.println(s.toUpperCase());
}
}
interface Interface1{
void printUpper(String s);
}
interface Interface2{
String mySubString(int a,String s,int b);
}
interface Interface3{
String mySubString(String s,int a,int b);
}
interface StudentInterface{
Student studentBuild(String name,int age);
}
class Student{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
运行，输出
-----引用类方法-----
110
110
-----引用对象的实例方法-----
LINGAOLU
LINGAOLU
-----引用类的实例方法-----
Gao
Gao
Gao
-----引用构造器-----
Student{name='林高禄', age=27}
Student{name='林高禄', age=27}
到此，方法引用的讲解完毕，虽然方法引用很简洁，并且是Lambda表达式的孪生兄弟，不过Lambda表达式能处理的额，方法的引用不一定能处理，比如例子中的useInterface2就是很好的证明，这个和useInterface3不同的就是把参数调换一下位置就不行了。
