JDK8新特性之函数式接口

函数式接口定义:有且只有一个抽象方法的接口

jdk8出现后，接口可以支持非抽象方法,也就是说函数式接口可以有多个非抽象的方法。
jdk8允许接口添加默认方法(default)、静态方法(static)，同时支持FunctionalInterface注解检查接口是否为函数式接口，如果不是会编译出错。

package com.basic.pojo;

@FunctionalInterface //函数式接口注解
public interface Animal {
    /**
     * 抽象方法
     */
    void  eat();

    /**
     * 默认方法
     * @param a
     * @param b
     */
     default void eatFoot(String a,String b){
         System.out.println(a);
     }

    /**
     * 静态方法
     */
      static void method(){
         System.out.println("静态方法");
     }
}

函数式接口的使用：可以作为方法的参数或者方法的返回值

package com.basic;
import com.basic.pojo.Animal;
public class FunctionDemo {
    public static void main(String[] args) {
        feedDog(new Animal() {
            @Override
            public void eat() {
                System.out.println("狗爱吃肉");
            }
        });
        //lambda表达式
        feedDog(()->System.out.println("狗爱吃肉"));

        Animal a = jinLian();
        a.eat();
    }
    //函数式接口作为方法的参数
    private static void feedDog(Animal animal){
        animal.eat();
    }
    //函数式接口作为方法的返回值
    private static Animal jinLian(){
        return new Animal() {
            @Override
            public void eat() {
                System.out.println("金莲想养一只猫");
            }
        };
    }
}

JDK自带的常用函数式接口：

1、supplier< T > 生产型接口:获取泛型类型的数据。
接口的抽象方法： T get();

public class FunctionDemo {
    public static void main(String[] args) {
        //lambda表达式调用
        System.out.println(method(() -> "abc"));
    }
    //生产型接口
    private static String method(Supplier<String>  supplier){
        //返回String类型的数据
        return supplier.get();
    }

2、Comsumer< T >消费型接口： 与生产接口相反，这是一个消费型接口。
接口的抽象方法： accept(T t);

public class FunctionDemo {
    public static void main(String[] args) {
        //lambda表达式调用
        method2("fbb",(String s)-> System.out.println(s));
    }
    //消费型接口
    private static void method2(String name,Consumer<String> consumer){
        consumer.accept(name);
    }

3、Predicate< T > 判断型接口： 这是用于条件判断的接口，返回布尔值。
抽象方法： Boolean test(T t);
值得注意的是: 判断型接口可以使用与(and)、或(or)、非(negate)连接。

public class FunctionDemo {
    public static void main(String[] args) {
    	//判断接口的简单引用,使用lambda表达式作为参数,调用方法,判断字符串是否长度大于0
        System.out.println(method3("abc", (str) -> str.length() > 0));
        //稍微复杂一点,使用and将两个判断型接口连接起来,最终结果就是两个判断的&关系.
        //第一个条件是: 判断字符串长度是否大于5
        //第二个条件是: 判断字符串是否以数字开头
        System.out.println(method4("123潘金莲", 
          (name) -> name.length() > 5, (name) -> Integer.parseInt(name.substring(0, 1)) > 0
          ||Integer.parseInt(name.substring(0, 1)) < 9));
    }
   
    //判断型接口： 判断字符串长度是否大于0
    private static  boolean method3(String str, Predicate<String> pre){
        return pre.test(str);
    }
    //复杂判断型接口: 判断字符串长度是否大于10,并且以数字开头
    private static  boolean method4(String str,Predicate<String> pre1,Predicate<String> pre2){
       return  pre1.and(pre2).test(str);
    }

4、Function< T,R> 类型转换接口： 将数据从T类型转换成R类型
抽象方法： R apply(T t);

public class FunctionDemo {
    public static void main(String[] args) {
    	//将传入的数值字符串转换成integer类型
        System.out.println(method5("123", (str) -> Integer.parseInt(str)));
        //将传入的字符串转换成integer类型，再加10，输出
        System.out.println(method06("123", (num) -> Integer.parseInt(num), 
        									(num) -> num + 10));
    }
    //简单引用类型转换型接口： 把传入的数值型字符串转换成integer类型
    private static  Integer method5(String str, Function<String,Integer> fun){
        return fun.apply(str);
    }
    //复杂使用，将传入的字符串转换成integer类型，再加10
    private static Integer method06(String num,Function<String,Integer> fun1,Function<Integer,Integer> fun2){
        return fun1.andThen(fun2).apply(num);
    }

总结一下： 函数式接口就是只有一个抽象方法的接口。当然其他非抽象的方法也可以有多个，函数式接口的出现，意味着lambda表达式也会出现，lambda可以用来简化函数式接口的代码。

希望可以帮到你！如有侵权，联系删除！

												灰色稻草人