Java方法引入

Java方法引入例子与实战

1、静态方法引入

定义一个函数式接口

/**
 * @author FPH
 */
@FunctionalInterface
public interface MessageInterface {
    String get(String id);
}

main方法中定义静态方法，并且返回类型与参数数量与类型都与函数式接口一致

使用lambda写法：

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        MessageInterface messageInterface=(a)->staticGet(a);
        System.out.println(messageInterface.get("123"));
    }
    public static void staticGet(String id){
        System.out.println(id);
    }
}

输出结果为：

亦能通过方法引入的形式使其更精简化

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        MessageInterface messageInterface= Main::staticGet;
        System.out.println(messageInterface.get("123"));
    }
    public static void staticGet(String id){
        System.out.println(id);
    }
}

2、实例方法引入

函数式接口不变，和静态方法引入不同的地方是，需要实例化该类，才能引入此方法

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        MessageInterface messageInterface= main::staticGet;
        System.out.println(messageInterface.get("123"));
    }
    public  String staticGet(String id){
        return id;
    }
}

3、构造函数方法引入

首先新建一个Student类

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

这里比较重要的是有参构造和无参构造

函数式接口：

/**
 * @author FPH
 */
@FunctionalInterface
public interface MessageInterface {
    Student get(String name,Integer age);
}

这里的参数取决于Student类中的构造函数，如果没有一个String类型与Integer类型的构造参数，则会报错

Main：

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        MessageInterface messageInterface= Student::new;
        System.out.println(messageInterface.get("小方",18));
    }
}

结果：

4、对象方法引入

函数式接口：

/**
 * @author FPH
 */
@FunctionalInterface
public interface MessageInterface {
    String get(Main main);
}

main方法：

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        MessageInterface messageInterface= Main::sendMessage;
        System.out.println(messageInterface.get(new Main()));
    }
    public String sendMessage(){
        return "123";
    }
}

结果：

5、实战

jdk内置函数接口：Function的apply方法：

设参数为string，返回为Integer类型，我们可以这样设计：

import java.util.function.Function;

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        Function<String,Integer> function=(str)-> {
            return str.length();
        };
        System.out.println(function.apply("asdasd"));
    }
}

但我们可以通过对象方法引入简写以上代码：

import java.util.function.Function;

/**
 * @author FPH
 */
public class Main {
    public static void main(String[] args) {
        Function<String,Integer> function=String::length;
        System.out.println(function.apply("asdasd"));
    }
}

依旧可以得到同样的结果。