Java8新特性 | 方法引用

方法引用

（一）体验方法引用

代码演示：

接口：

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

测试类：

public class printableDemo {
    public static void main(String[] args) {
        usePrintable(s -> System.out.println(s));

        //方法引用符  ::
        usePrintable(System.out::println);
        //可推导的就是可省略的
    }

    public static void usePrintable(Printable p) {
        p.printString("我爱Java");
    }
}

（二）方法引用符

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

常见的引用方式：

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

1.引用类方法

代码演示：

接口：

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

测试类：

public class ConverterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useConverter((String s) -> {
            return Integer.parseInt(s);
        });
        //简写Lambda表达式
        useConverter(s -> Integer.parseInt(s));
        //方法引用
        useConverter(Integer::parseInt);
        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
    }

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

2.引用对象的实例方法

代码演示：

接口：

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

类（PrintString）：

public class PrintString {
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

测试类：

public class PrinterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        usePrinter((s -> System.out.println(s.toUpperCase())));
        //方法引用
        PrintString p = new PrintString();
        usePrinter(p::printUpper);
        //Lambda表达式被对象的实例方法代替的时候，它的形式参数全部传递给该方法作为参数
    }

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

3.引用类的实例方法

代码演示：

接口：

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

测试类：

public class MyStringDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useMyString((String s,int x,int y) -> {
            return s.substring(x,y);
        });
        useMyString((s,x,y) -> s.substring(x,y));
        //方法引用
        useMyString(String::substring);
        //Lambda表达式被类的实例方法替代的时候
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数
    }

    private static void useMyString(MyString my) {
        String s = my.mySubString("helloWorld", 0, 5);
        System.out.println(s);
    }
}

4.引用构造器

定义学生类：

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;
    }
}

接口：

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

测试类：

public class StudentDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useStudentBuilder((String name,int age) -> {
            Student s = new Student(name,age);
            return s;
        }) ;
        //简写Lambda表达式
        useStudentBuilder((name,age) -> new Student(name,age));

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

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