方法引用符

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

2：方法引用是Lambda的孪生兄弟

eg:

定义接口Printable，有一个方法printInt：

public interface Printable {
    void printInt(int i);
}

测试类：

public class Main {
    public static void main(String[] args) {
        //调用usePrintable方法
        //usePrintable(i->System.out.println(i));
        
        //方法引用
        usePrintable(System.out::println);
    }

    public static void usePrintable(Printable p){
        p.printInt(666);
    }
}

//666

Lambda表达式支持的方法引用

常见的引用方式：

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

引用类方法

引用类方法就是引用类的静态方法

格式：类名::静态方法

范例：Integer::parseInt

eg:

定义接口Converter，有一个方法convert：

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

测试类：

public class Main {
    public static void main(String[] args) {
        //调用useConverter方法
        //useConverter(s->Integer.parseInt(s));
        
        //方法引用
        useConverter(Integer::parseInt);
    }

    private static void useConverter(Converter c){
        int num = c.convert("666");
        System.out.println(num);
    }
}

//666

引用对象的实例方法

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

格式：对象::成员方法

范例：“HelloWorld”::toUpperCase

eg:

定义一个类PrinterString，有一个方法printUpper：

public class PrinterString {
    //输出字符串s参数变成大写的数据
    public void printUpper(String s){
        System.out.println(s.toUpperCase());
    }
}

定义一个接口Printer，有一个方法printUpperCase：

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

测试类：

public class PrinterDemo {
    public static void main(String[] args) {
        usePrinter(s->System.out.println(s.toUpperCase()));
        
        //方法引用
        PrinterString ps = new PrinterString();
        usePrinter(ps::printUpper);
    }

    private static void usePrinter(Printer p){
        p.printUpperCase("halou");
    }
}

引用类的实例方法

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

格式：类名::成员方法

范例：String::substring

eg:

定义一个接口MyString，有一个方法mySubString：

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

测试类：

public class Main {
    public static void main(String[] args) {
        /*useMyString((String my, int x, int y)->{
            return my.substring(x,y);
        });*/
        //useMyString((s,x,y)->s.substring(x,y));
        
        //方法引用
        useMyString(String::substring);
    }

    private static void useMyString(MyString p){
        System.out.println(p.mySubString("HelloWorld",2,5));
    }
}

引用构造器

引用构造器就是引用构造方法

格式：类名::new

范例：Student::new

eg:

定义一个学生类：

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，有一个方法build：

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

测试类：

public class Main {
    public static void main(String[] args) {

        /*useStudentBuilder((String name, int age)->{
            return new Student(name,age);
        });*/

        //useStudentBuilder((name,age)->new Student(name,age));

        //方法引用
        useStudentBuilder(Student::new);

    }

    private static void useStudentBuilder(StudentBuilder sb){
        Student s = sb.build("nn",21);
        System.out.println(s.getName()+" "+s.getAge());
    }
}