一、使用场景

当我们在Lambda表达式中所要用到的解决方案，在别的地方已经存在时，我们就没有必要再重写重复逻辑。

方法引用就是通过方法引用来使用已经存在的解决方案

案例

比如之前的一个Lambda表达式的案例

1.定义一个接口(show),接口中定义一个抽象方法：void show()

2.定义一个测试类，在测试类中提供两个方法

方法一：useShow(Intert i)

方法二：主方法，调用useShow方法

那么我们就可以这样写

public class Demo01 {
    public static void main(String[] args) {
       // useShow(i-> System.out.println("最美不过姑娘你"));
        //方法引用
        useShow(System.out::println);
​
    }
    private static void useShow(Inter i){
        i.show("最美不过姑娘你");
​
    }
}

二、方法引用符号— ：：两个冒号

推导与省略

1.如果使用Lambda表达式，那么根据可推导就是可省略的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导

2.如果使用方法引用，也是同样可以根据上下文进行推导

3.方法引用是Lambda的孪生兄弟

三、Lambda表达式支持的方法引用

常见的引用方式：

1.引用类方法,其实就是引用类的静态方法

格式：类名：：静态方法

示例：Integer：：parseInt

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

练习：

定义一个接口(Integer),定义一个抽象方法 Convert(String s)

定义一个测试类，在测试类中提供一个方法 useConvert并调用

public class ConvertDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useConvert(c-> Integer.parseInt(c));
        //方法引用
        useConvert(Integer::parseInt);
    }
    private static void useConvert(Convert c){
        int convert = c.Convert("666");
        System.out.println(convert);
    }
}

2.引用对象的实例方法(引用类中的成员方法)

格式：对象::成员方法

示例：”Hello world“::toUpperCase

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

练习：

定义一个类(PrintString),定义成员方法方法 public void printUpper(String s):把字符串参数转换为大写的数据，然后在控制台输出

定义一个接口(Printer),里面定义了一个抽象方法 void printUpperCase(String s)

定义一个测试类(PrinterDemo),提供usePrinter(Printer p)方法调用

PrintString 类

package Demo042501;
​
public class PrintString {
    //无参构造
    public PrintString(){}
    //成员方法
    public  void printUpper(String s){
        String s1 = s.toUpperCase();
        System.out.println(s1);
    }
}

printer接口

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

测试类

public class PrinterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        usePrinter(s-> System.out.println(s.toUpperCase()));
        //方法引用，引用对象的成员方法
        //创建对象
        PrintString ps=new PrintString();
        usePrinter(ps::printUpper);
    }
    public static void usePrinter(Printer p){
        p.printUpperCase("abcd");
    }
}

3.引用类的实例方法(引用类中的成员方法)

格式：类名::成员方法

示例：String::substring

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

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

Lambda表达式被类的实例方法替代的时候

1.第一个参数作为调用者

2.后面的参数全部传递给该方法作为参数

练习:

定义一个接口(MyString),里面定义一个抽象方法：String mySubString(String s,int a,int b);

定义一个测试类，定义方法useMyString(MyString ms);并调用

MyString接口

package Demo042502;
​
public interface MyString {
    String mySubString(String s,int a,int b);
}

useMyString类

package Demo042502;
​
public class MyStringDemo {
    public static void main(String[] args) {
        useMySubString((s,a,b)->s.substring(a,b));
    }
    private static void useMySubString(MyString ms){
        String ss = ms.mySubString("最美不过姑娘你", 0, 3);
        System.out.println(ss);
    }
}

4.引用构造器(引用构造方法)

格式：类名::new

示例：Student::new

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

练习

定义一个类(Student)，里面有两个成员变量(name,age)并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法

package Demo042503;
​
public class Student {
    private String name;
    private int age;
    //无参构造
    public Student(){}
    //带参构造
    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;
    }
}

定义一个接口(StudentBuilder),定义一个抽象方法Student build(Student s)

package Demo042503;
​
public interface StudentBuilder {
    Student build(String name,int age);
}

定义一个测试类，提供useStudentBuilder(StudentBuilder sb)

package Demo042503;
​
public class StudentDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useStudentBuilder(((name, age) -> new Student(name,age)));
        //方法引用
        useStudentBuilder(Student::new);
​
    }
    private static void useStudentBuilder(StudentBuilder sb){
        Student student = sb.build("最美不过姑娘你", 10000);
        System.out.println(student.getName()+","+student.getAge()+"年");
​
    }
}