投稿
  1. 首页
  2. 随笔

重学Java 8新特性 | 第6讲——方法引用与构造器引用

古墓探秘 • 2022-12-17 • 随笔 • 阅读 27

重学Java 8新特性 | 第6讲——方法引用与构造器引用,第1张

重学Java 8新特性 | 第6讲——方法引用与构造器引用 我们为什么要使用方法引用与构造器引用呢？

如果不使用Lambda表达式进行程序编写的话，那么大可不必关注方法引用和构造器引用，但是如果使用Lambda表达式，再配合方法引用和构造器引用之后，那么就可以使Lambda编写匿名内部类的代码变得更加简洁。在不影响性能的前提下简洁的代码可以增强代码的可读性，当然是在阅读者知晓对方语法的前提下。

方法引用 什么是方法引用？

当要传递给Lambda体的 *** 作，已经有实现的方法了，那么这时便可以使用方法引用了。或者，你也可以理解为方法引用是Lambda表达式的另外一种表现形式。

不过有一点需要我们注意，就是Lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的参数列表与返回值类型保持一致！

方法引用的语法格式

方法引用使用 *** 作符::将方法名和对象或类的名字分隔开来。而且，方法引用主要有如下三种固定语法格式。

  • 第一种语法格式：对象::实例方法名。
  • 第二种语法格式：类::静态方法名。
  • 第三种语法格式：类::实例方法名。

接下来，我会为大家分别一一介绍这三种语法格式。

第一种语法格式：对象::实例方法名

观察如下Java程序，你会发现在Lambda体中有一个println方法已经完成了我们要 *** 作的功能，即完成了在Lambda体中所写的功能。

package com.meimeixia.java8;

import org.junit.Test;

import java.io.PrintStream;
import java.util.function.Consumer;


public class TestMethodRef {

    // 对象::实例方法名
    @Test
    public void test1() {
        // 未使用方法引用时
        // Consumer con = (x) -> System.out.println(x);
        PrintStream ps1 = System.out;
        Consumer con = (x) -> ps1.println(x);
    }

}

那么在这种情况下我们就可以使用方法引用了！

package com.meimeixia.java8;

import org.junit.Test;

import java.io.PrintStream;
import java.util.function.Consumer;


public class TestMethodRef {

    // 对象::实例方法名
    @Test
    public void test1() {
        // 未使用方法引用时
        // Consumer con = (x) -> System.out.println(x);
        PrintStream ps1 = System.out;
        Consumer con = (x) -> ps1.println(x);

        // 使用方法引用时
        PrintStream ps = System.out;
        Consumer con1 = ps::println;
        // 以上还可以简写为下面这样，相信大家应该都看得懂
        Consumer con2 = System.out::println;
        con2.accept("abcdef");
    }

}

在使用方法引用时，有一个前提，大家得注意一下，就是需要实现的接口（例如Consumer）中的抽象方法的参数列表与返回值类型要与我们当前调用的Lambda体中方法的参数列表与返回值类型保持一致！

再来看另外一个案例，使用Lambda表达式来实现供给型接口，如下所示。

@Test
public void test2() {
    // 未使用方法引用时
    Employee emp = new Employee();
    Supplier sup = () -> emp.getName();
    String str = sup.get();
    System.out.println(str);
}

其中，Employee实体类的代码如下所示。

package com.meimeixia.java8;


public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee() {

    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

}

大家发现没有在以上Lambda体中是不是已经有实现的方法了啊，所以这时我们就可以使用方法引用了。

@Test
public void test2() {
    // 未使用方法引用时
    Employee emp = new Employee();
    Supplier sup = () -> emp.getName();
    String str = sup.get();
    System.out.println(str);

    // 使用方法引用时
    Supplier sup2 = emp::getAge;
    Integer num = sup2.get();
    System.out.println(num);
}
第二种语法格式：类::静态方法名

使用方法引用的这种格式，可以引用类的静态方法，就像下面这样。

// 类::静态方法名
@Test
public void test3() {
    // 未使用方法引用时
    Comparator com = (x, y) -> Integer.compare(x, y);

    // 使用方法引用时
    Comparator com1 = Integer::compare;
}

如果你怀疑上述使用方法引用时的写法，那么不妨去查看一下Integer类中compare方法的参数列表与返回值类型是否和Comparator接口中compare方法的参数列表与返回值类型保持一致。不用想，肯定是保持一致的，保持一致就可以像上面这样使用方法引用来书写代码了。

第三种语法格式：类::实例方法名

使用方法引用的这种格式得有一个前提，也可以说是规则，即若Lambda表达式参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，则可使用ClassName::method这种格式来书写代码。不知道，大家能记住嘛？

// 类::实例方法名
@Test
public void test4() {
    // 未使用方法引用时，来比较两个字符串是不是一样的。注意，BiPredicate接口是Predicate接口的子接口
    BiPredicate bp = (x, y) -> x.equals(y);

    // 使用方法引用时
    BiPredicate bp2 = String::equals;
}
构造器引用

构造器引用的语法格式是ClassName::new。它与函数式接口相结合，自动与函数式接口中方法兼容，可以把构造器引用赋值给定义的方法，只不过构造器的参数列表要与接口中抽象方法的参数列表保持一致！

为了演示构造器引用的使用，我们在Employee实体类中多写几个构造方法，如下所示。

package com.meimeixia.java8;


public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee() {

    }

    public Employee(int id) {
        this.id = id;
    }

    public Employee(int id, int age) {
        this.id = id;
        this.age = age;
    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

}

然后，我们就能使用构造器引用的方式来书写代码了。

// 构造器引用
@Test
public void test5() {
    // 未使用构造器引用时
    Supplier sup = () -> new Employee();

    // 使用构造器引用时
    Supplier sup2 = Employee::new;
    Employee emp = sup2.get();
    System.out.println(emp);
}

不知你有没有想过，Employee实体类中有好几个构造器，那么现在调用的是哪个构造器呢？道理其实跟方法引用一样，由于构造器的参数列表要与接口中抽象方法的参数列表保持一致，所以此时调用的必然就是无参的构造器，也就是说Java 8会根据函数式接口中抽象方法的参数列表自动匹配对应的构造器。

如果此时我们想要调用Employee实体类中一个参数的构造器，那么该怎么办呢？是不是该像下面这样做啊！

@Test
public void test6() {
    Function fun = (x) -> new Employee(x);

    Function fun2 = Employee::new; // 注意，此时调用的是Employee实体类中一个参数的构造器
    Employee emp = fun2.apply(101);
    System.out.println(emp);
}

举一反三，大家试着思考一下，如果此时想要调用Employee实体类中两个参数的构造器，那么又该怎么办呢？很简单嘛，代码像下面这样写就行了。

@Test
public void test6() {
    Function fun = (x) -> new Employee(x);

    Function fun2 = Employee::new; // 注意，此时调用的是Employee实体类中一个参数的构造器
    Employee emp = fun2.apply(101);
    System.out.println(emp);

    // BiFunction接口是Function接口的子接口
    BiFunction bf = Employee::new; // 注意，此时调用的是Employee实体类中两个参数的构造器
}
数组引用

数组引用的语法格式是Type[]::new。

下面我会通过一个案例来简单使用一下数组引用。

// 数组引用
@Test
public void test7() {
    // 未使用数组引用时
    Function fun = (x) -> new String[x];
    String[] strs = fun.apply(10);
    System.out.println(strs.length);

    // 使用数组引用时
    Function fun2 = String[]::new;
    String[] strs2 = fun2.apply(20);
    System.out.println(strs2.length);
}

至此，Java 8中有关Lambda表达式的所有内容我就算是总结完了！接下来咱们就要开始学习Java 8中另外一个最核心的新特性（即Stream API）了。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5696441.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
古墓探秘 古墓探秘 一级用户组
0 0
上一篇 2022-12-17
下一篇 2022-12-17

发表评论

登录后才能评论

评论列表（0条）

保存