方法引用

最新推荐文章于 2022-12-27 20:16:56 发布

无；忧

最新推荐文章于 2022-12-27 20:16:56 发布

阅读量138

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_52284319/article/details/111568314

版权

Java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

方法引用

在使用Lambda表达式的时候，实际上我们传递的是一段解决问题的代码，给什么参数做什么操作

Lambda冗余的场景

比如我们想要打印一个文本内容

准备函数式接口

public interface Printable {	
    public abstract void print(String str);
}

准备一个测试类

public class Class01Method {

    public static void printString(Printable p){
        p.print("Hello");
    }
    public static void main(String[] args) {
        //传统的Lambda表达式
        printString((String str) -> {
            System.out.println(str);
        });
        // 打印流对象已经确定
        /*PrintStream printStream = System.out;
        //通过对象来引用对应的成员方法
        printString(printStream::println);*/
        printString(System.out::println);
    }
}

在测试类定义一个静态方法，静态方法传递一个函数式接口Printable，函数式接口，定义唯一一个抽象方法print，这个print方法接受一个字符串参数，目的就是为了打印接受的字符串参数，通常我们可以使用lambda表达式来实现以上需求。

但是经过观察，对字符串进行控制台打印输出的操作方法，明明已经有了现成的执行方案，System.out对象中有一个方法println(String str)，所以我们可以直接通过对象名来引用该方法println来实现在控制台打印输出字符串内容。

PrintStream printStream = System.out;
//通过对象来引用对应的成员方法
printString(printStream::println);

注意：其中的双冒号::写法，被称之为方法引用，两个冒号是一种新语法

方法引用符号

双冒号::也被归置为引用运算符，

使用方法引用的使用场景

通过对象名来引用成员方法

//先准备一个类，类中定义一个成员方法
public class Class02Method {
    //定义一个成员方法，传递一个字符串
    public void printUpperCaseString(String str){
        System.out.println(str);
    }
}
//准备一个函数式接口
public interface Printable {
	//定义抽象方法
    public abstract void print(String str);
}
//准备测试类
public class Class01Method {
    public static void printString(Printable p){
        p.print("Hello");
    }
    public static void main(String[] args) {
        printString((str) -> {
            Class02Method method = new Class02Method();
            method.printUpperCaseString(str);
        })
        /*
        使用方法引用优化Lambda
            对象已经存在method
            成员方法已经存在
            所以我们就可以使用对象名来调用成员方法
         */
        //首先对象已经存在
        Class02Method method = new Class02Method();
        printString(method::printUpperCaseString);
    }
}

通过类名来引用静态方法

比如：java.lang.Math 类中都是静态方法

//定义一个函数式接口
@FunctionalInterface
public interface Demo01MathStaticMethod {
    //定义抽象方法
    double calculateAbs(double d);
}
//定义一个测试类
public class Demo02MethodStatic {
    //定义一个静态方法，该方法中传递一个函数式接口,再传递一个浮点数
    public static double calc(double d, Demo01MathStaticMethod math){
        return math.calculateAbs(d);
    }

    public static void main(String[] args) {
        //传统的Lambda表达式写法
        double num = calc(-3.14, (d) -> {
            return Math.abs(d);
        });
        System.out.println(num);
        /*
        使用方法引用进行优化Lambda
        首先类型是已经确定的
        类中的静态方法是已经确定的
        使用类名引用类中的静态方法
         */
        double d = calc(-3.14, Math::abs);
        System.out.println(d);
    }
}

备注：

Lambda表达式写法：d->Math.abs(d)

方法引用写法： Math::abs

这两种写法是等价的

通过super来引用成员方法

如果存在继承关系，当Lambda中需要使用super调用时，也可以使用方法引用来优化Lambda表达式。

//定义一个父类
public class Animal {
    //定义一个成员方法 交流的方法
    public void talk() {
        System.out.println("Hello 我是一只动物");
    }
}
//定义一个函数式接口
@FunctionalInterface
public interface Meet {
    //定义一个抽象方法 见面的方法
    void meet();
}
//定义子类
public class Cat extends Animal {
    @Override
    public void talk() {
        System.out.println("Hello 我是一只猫");
    }

    //定义一个方法 方法的参数传递一个函数式接口
    public void meet(Meet m) {
        m.meet();
    }

    //定义一个成员方法 沟通的方法
    public void commun() {
        //传统的Lambda表达式的写法
        meet(() -> {
            //创建父类对象
            //调用父类对象
            Animal animal = new Animal();
            animal.talk();
        });
        //使用父类当中的方法 直接用super来调用
        meet(() -> super.talk());
        /*
        使用super关键字来引用成员方法
        super已经存在
        父类当中的成员方法talk已经存在
        可以使用super引用父类当中的成员方法
         */
        //优化的结果
        meet(super::talk);
    }
    public static void main(String[] args) {
        new Cat().commun();
    }
}

通过this来引用本类当中的成员方法

this指代当前对象，如果需要引用的方法就是本类当中的成员方法，那么可以使用this::成员方法格式来优化Lambda表达式

@FunctionalInterface
public interface Study {
    //定义一个学习的抽象方法
    void study();
}
定义一个学生类
public class Student {

    //定义一个成员方法，方法的参数传递一个函数式接口Study
    public void study(Study s){
        s.study();
    }

    //定义一个work方法
    public void work(){
        System.out.println("我今天很开心，因为我学习了");
    }

    //定义一个成员方法 快乐的方法
    public void toHappy() {
        //传统的Lambda表达式
        study(()->{
            //创建对象
            Student student = new Student();
            student.work();
        });
        //使用this优化Lambda
        //study(s)
        study(this::work);

    }

    public static void main(String[] args) {
        new Student().toHappy();
    }
}

类的构造器引用

由于构造器的名称与类名完全一样，所以构造器的引用使用 类名称::new的格式来表示的

//定义一个mode类
public class Person {

    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
//定义一个函数式接口
@FunctionalInterface
public interface PersonCreate {

    //定义一个抽象方法
    Person createPerson(String name);
}
//定义测试类
public class TestConstructorMethod {
    //定义一个方法，传入一个函数式接口PersonCreate,再传入一个字符串
    public static void printPersonName(String name,PersonCreate create){
        System.out.println(create.createPerson(name).getName());
    }
    public static void main(String[] args) {
        //使用传统的Lambda表达式
        printPersonName("小孙",name -> new Person(name));
        //使用构造器来优化Lambda表达式
        printPersonName("小孙",Person::new);
    }
}

数组的构造器引用

数组也是Object的子类对象，所以同样具有构造器，只是语法有些以区别

//定义一个函数式接口
@FunctionalInterface
public interface BuildArrays {
    //定义唯一的抽象方法
    int[] buildArrays(int length);
}
//定义实现类
public class Demo01ArraysConstructorMethod {

    //定义一个方法，方法中传递一个函数式接口，还要传递一个数组的长度
    public static int[] buildArrays(int length,BuildArrays buildArrays){
        return buildArrays.buildArrays(length);
    }

    public static void main(String[] args) {
        //使用Lambda表达式操作
        int[] arr01 = buildArrays(10, length -> new int[length]);
        System.out.println(arr01.length);
        //使用数组的构造器引用来优化Lambda表达式
        int[] arr02 = buildArrays(10, int[]::new);
        System.out.println(arr02.length);
    }
}