Java方法引用

1|0体验方法引用

通过方法引用，来使用已经存在的方案。

1. 定义一个接口，里面有一个抽象方法：

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

2. 定义一个测试类：

public class PrintDemo {
    public static void main(String[] args) {
        /*方式一
        以Lambda表达式的方式，调用了接口的实现类，重写了接口中的方法
        接口作为参数，实际上参数是接口的实现类*/
        usePrintable(s -> System.out.println(s));
 
        /*方式二
        方法引用符 ::
        参数s：可推导的就是可省略的*/
        usePrintable(System.out::println);
    }
 
    /**
     * 一个以接口对象为形式参数的方法
     * @param p 接口对象
     */
    private static void usePrintable(Printable p) {
        System.out.println("卡塔尔世界杯");
    }
}

3. 运行结果：

卡塔尔世界杯
卡塔尔世界杯

---

2|0方法引用符

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

推导与省略

• Lambda表达式：根据“可推导就是可省略”原则，无需指定参数类型，也无需指定重载形式，他们都将被自动推导
• 方法引用：同样可根据上下文推导
• Lambda表达式可以使用方法引用改进

1. 定义一个接口，里面有一个抽象方法

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

2. 定义测试类

public class PrintDemo1 {
    public static void main(String[] args) {
        usePrintable(i -> System.out.println(i));
        usePrintable(System.out::println);
    }
 
 
    private static void usePrintable(Printable1 p) {
        p.printInt(123);
    }
}

3. 运行结果

123
123

---

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

常见的引用方式

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

---

3|1引用类方法

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

• 格式：类名::静态方法

1. 定义一个接口，里面有一个抽象方法

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

2. 定义一个测试类

public class ConvertDemo {
    public static void main(String[] args) {
    	//Lambda
        useConvert(s -> Integer.parseInt(s));
        //引用类方法
        //Lambda表达式被引用类方法替代时，它的形式参数全部传递给静态方法作为参数
        useConvert(Integer::parseInt);
    }
 
 
    private static void useConvert(Convert c) {
        int i = c.convert("123");
        System.out.println(i);
    }
}

3. 运行结果

123
123

---

3|2引用对象的实例方法

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

• 格式：对象::成员方法

1. 定义一个类，里面有一个方法

public class PrintString {
    /**
     * 把字符串参数变成大写，输出到控制台
     * @param s 字符串
     */
    public void printUpper(String s){
        System.out.println(s.toUpperCase());
    }
}

2. 定义一个接口，里面有一个抽象方法

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

3. 测试类

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

4. 运行结果

HOW ARE YOU
HOW ARE YOU

---

3|3引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法
格式：类名::成员方法

1. 定义一个接口，里面有一个抽象方法

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

2. 定义一个测试类

public class MyStringDemo {
    public static void main(String[] args) {
        //Lambda表达式，截取字符串
        useMyString((s, x, y) -> s.substring(x, y));
 
        //引用类的实例方法
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数
        useMyString(String::substring);
    }
 
    private static void useMyString(MyString m) {
        System.out.println(m.mySubString("今天天气很凉快", 2, 6));
    }
}

3. 运行结果

天气很凉
天气很凉

---

3|4引用构造器

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

• 格式：类名::new

1. 定义一个学生类，里面有两个成员变量（name,age），并提供无参构造方法和带参构造方法，以及成员变量的set和get方法

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

2. 定义一个接口，里面有一个抽象方法

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

3. 定义一个测试类

public class StudentDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useStudentBuilder((a, b) -> new Student(a, b));
 
        //引用构造器
        //Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
        useStudentBuilder(Student::new);
    }
 
    private static void useStudentBuilder(StudentBuilder s) {
        Student stu = s.build("钱学森", 28);
        System.out.println(stu.getName() + "-" + stu.getAge());
    }
}

4. 运行结果
   ``java
   钱学森-28
   钱学森-28

__EOF__

本文作者：茶碗儿
本文链接：https://www.cnblogs.com/chawaner/p/17011638.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！