java基础之Java8新特性-方法引入

目录

1.简介

2.方法引入

方法引入遵循规范

方法引入种类

1.静态方法引入

2.对象方法引入

3.实例方法引入

4.构造函数引入

---

1.简介

方法引用是 Java 8 中引入的另一个重要特性，它提供了一种简洁的语法来直接引用现有方法或构造函数。方法引用可以看作是 Lambda 表达式的一种简化写法，它可以让代码更加简洁易懂。

什么是Lambda 表达式呢？

可以参考另一篇文章：

java基础之Java8新特性-Lambda-CSDN博客https://blog.csdn.net/qq_62262918/article/details/135395534?spm=1001.2014.3001.5501

示例代码仓库地址：

j8-new-feature: java8新特性示例Demo (gitee.com)https://gitee.com/mi9688-wine/j8-new-feature

2.方法引入

方法引入遵循规范

当使用方法引用时，被引用的方法的参数类型和返回类型必须与函数式接口的抽象方法相匹配。

方法引入种类

方法引入共有四种分别为静态方法引用（类名::静态方法名）、对象方法引入（类名::实例方法名）、实例方法引入（对象名::方法名）、构造函数引入（类名::new）。

1.静态方法引入

首先我们定义一个函数接口

@FunctionalInterface
public interface MessageInterface {
    void printMessage(String msg); // 打印内容
}

接着我们调用该接口的printMessage方法就需要重写该接口的该方法。

传统使用匿名内部类的方式

        //传统匿名内部类方式
        new MessageInterface(){

            @Override
            public void printMessage(String msg) {
                System.out.println("打印内容:"+msg);
            }
        }.printMessage("hello");

使用Lambda的方式

        //使用Lambda
        ((MessageInterface) msg -> System.out.println("打印内容:" + msg)).printMessage("hello");

使用静态方法引入

定义出该静态方法（在某个类里面）这里是图方便直接写在在Test01类里面定义的，然后引用

    //定义静态方法
    public static void staticPrintMessage(String msg){
        System.out.println("打印内容:"+msg);
    }

        //静态方法引入
        MessageInterface m=Test01::staticPrintMessage;
        m.printMessage("hello");

完整示例代码

public class Test01 {
    public static void main(String[] args) {
        //传统匿名内部类方式
        new MessageInterface(){

            @Override
            public void printMessage(String msg) {
                System.out.println("打印内容:"+msg);
            }
        }.printMessage("hello");


        //使用Lambda
        ((MessageInterface) msg -> System.out.println("打印内容:" + msg)).printMessage("hello");

        //静态方法引入
        MessageInterface m=Test01::staticPrintMessage;
        m.printMessage("hello");
        //简化的写法
        ((MessageInterface) Test01::staticPrintMessage).printMessage("hello");


    }
    //定义静态方法
    public static void staticPrintMessage(String msg){
        System.out.println("打印内容:"+msg);
    }
}

可以看到使用方法引入对比Lambda表达式的写法看起来更简短，直接类名::静态方法名；相对于Lambda为何没有参数列表呢？或者说直接省略不写呢？原因很简单就是：被引用的方法的参数类型和返回类型必须与函数式接口的抽象方法相匹配。既然是匹配的那就不需要再写了。

其实也存在一种特例，就是当函数式接口的方法返回类型是void的时候，你定义的被引用方法的返回类型除了是void也可以是任意类型。

比如

@FunctionalInterface
public interface MessageInterface {
    void printMessage(String msg); // 打印内容
}

 public static String staticPrintMessage(String msg){
        System.out.println("打印内容:"+msg);
        return msg;
    }

        //静态方法引入
        MessageInterface m=Test01::staticPrintMessage;
        m.printMessage("hello");

这样会出现返回类型不一致的情况而不报错，可以正常运行。我理解为就是当函数式接口方法返回类型是void就只需要关注方法的参数和方法的行为，而不需要关注方法的返回值。这里的返回值当作无效的返回值处理了。只有当函数式接口方法返回类型不是void,也就是有返回值时才会关注方法的返回值，并校验是否一致。

如果用说Lambda表达式的方式实现函数式接口，本质就是传入一个匿名函数参数；那用方法引入的方式实现函数式接口本质上也是传入了一个函数参数，只不过这个函数是通过方法引用的方式来实现的，它并不是匿名的。

2.对象方法引入

首先在Message类写个计算内容行数的方法

 //计算信息内容行数
    public int lineCount(){
        return (this.content.length()/80)+1;
    }

定义函数接口

@FunctionalInterface
public interface MessageInterface3 {
    int getMessageRow(Message msg); //获取信息内容行数
}

实现函数接口

  public static void main(String[] args) {
        //Lambda
        MessageInterface3 m = (msg) -> {
            return msg.lineCount();
        };
        System.out.println(m.getMessageRow(new Message()));

        System.out.println("----------------------");
        //对象方法引入
        MessageInterface3 m1 = Message::lineCount;
        System.out.println(m1.getMessageRow(new Message()));
    }

看到这里你可能会思考为何这个lineCount方法不是静态方法却可以直接通过类名::方法名引用呢？

其实前面已经讲过了，就是你通过方法引入实现函数接口就必须保证被引用的方法的参数类型和返回类型必须与函数式接口的抽象方法相匹配，既然匹配了是不是可以省略了。

既然这个函数接口的getMessageRow方法入参是Message对象，那要实现它内部是不是得调用Message对象的?lineCount方法，传统匿名内部类代码：

 //匿名内部类
        MessageInterface3 m0 = new MessageInterface3() {
            @Override
            public int getMessageRow(Message msg) {
                return msg.lineCount();
            }
        };
        System.out.println(m0.getMessageRow(new Message()));

这里使用对象方法引入你就可以理解为把 ” (Message msg) “ 和 ”??msg.lineCount(); “ 省略成 ” Message::lineCount; “。

3.实例方法引入

实例方法引入就是new出来该对象，然后引用该实例对象的方法作为函数式接口的方法实现。

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

        //实例化
        Test02 t = new Test02();
        //实例方法引用
        ((MessageInterface)t::printMessage).printMessage("Hello");

    }
    public void printMessage(String msg){
        System.out.println("打印内容:"+msg);
    }
}

4.构造函数引入

实现该函数接口需要重写getMessage方法返回值是Message类型

@FunctionalInterface
public interface MessageInterface2 {
    Message getMessage();
}

public static void main(String[] args) {
        //使用Lambda
        MessageInterface2  m1 = () -> new Message();
        System.out.println( m1.getMessage());

        System.out.println("----------------------");
        //使用构造方法引用
        MessageInterface2 m2 = Message::new;
        System.out.println( m2.getMessage());
        //简化写法
        System.out.println("----------------------");
        System.out.println(((MessageInterface2) Message::new).getMessage());
    }