lambda方法引入

什么是方法引入：

方法引入：需要结合lambda表达式能够让代码变得更加精简。

1.匿名内部类使用。

2.Lambda调用匿名内部类。

3.方法引入。

 

方法引入的几种：

1.静态方法引入：　　类名::（静态）方法名称

2.对象方法引入：　　类名:: 实例方法名称

3.实例方法引入：　　new 对象   对象实例:: 方法引入

4.构造函数引入：　　类名::new

 

一、静态方法引入：

package com.mayikt.test;

import com.mayikt.service.MessageInterface;

/**
 * 静态方法引入
 */
public class Test006 {

    public static void main(String[] args) {
        MessageInterface messageInterface = (a) -> System.out.println(a);
        messageInterface.get(123);

        /**
         * 在lambda表达式中方法体直接引入方法
         */
        MessageInterface messageInterface2 = (a) -> Test006.staticGet(a);
        messageInterface.get(12);

        /**
         * 方法引入实际上就是，lambda表达式中方法体直接引入方法
         */
        MessageInterface messageInterface3 = Test006::staticGet;
        messageInterface3.get(3);

        /**
         * Test006::staticGet 为何能够等于 (a) -> Test006.staticGet(a);
         *
         * 1.staticGet的参数列表和返回值与MessageInterface都是一样的。
         */
    }


    public static void staticGet(Integer a){
        System.out.println("staticGet a :" + a);
    }
}

package com.mayikt.service;

@FunctionalInterface
public interface MessageInterface {

    void get(Integer a);
}　　

　

方法引入规则：

方法引入实际上就是lambda表达式中直接引入的方法。

必须遵循规范：引入的方法参数列表和返回类型，必须要和函数接口参数列表、返回类型保持一致。

 

二、实例方法引入：

package com.mayikt.test;

import com.mayikt.service.MessageInterface2;

public class Test007 {

    public static void main(String[] args) {
        MessageInterface2 messageInterface2 = () -> "阿收到货后";
        System.out.println(messageInterface2.getMessage());

        Test007 test007 = new Test007();
        MessageInterface2 messageInterface3 = () -> test007.objGet();
        System.out.println(messageInterface3.getMessage());

        /**
         * 实例方法引入的规则和静态方法引入规则一样
         */
        MessageInterface2 messageInterface4 = test007::objGet;
        System.out.println(messageInterface4.getMessage());

    }

    public String objGet(){
        return "阿收到货后";
    }
}

@FunctionalInterface
public interface MessageInterface2 {

    String getMessage();
}

　　

三、构造函数引入

public class Test008 {

    public static void main(String[] args) {
        MessageInterface3 messageInterface3 = () -> new MessageEntity();

        /**
         * 构造函数引入，遵循规范：函数接口返回类型::new
         */
        MessageInterface3 messageInterface4 = MessageEntity::new;
    }

}

　　

@FunctionalInterface
public interface MessageInterface3 {

    MessageEntity getMessageEntity();
}

　　

public class MessageEntity {

    private String messageId;
    private String messageName;

    public MessageEntity(){

    }

    @Override
    public String toString() {
        return "MessageEntity{" +
                "messageId='" + messageId + '\'' +
                ", messageName='" + messageName + '\'' +
                '}';
    }
}

　　

四、对象方法引入

public class Test009 {

    public static void main(String[] args) {
       Function<String, Integer> function = (str) -> str.length();
       System.out.println(function.apply("aksdhalsdh"));

       Function<String, Integer> function2 = String::length;
       System.out.println(function2.apply("aksdhalsdh"));
    }

}