【Java 四大函数式接口和自定义函数式接口】

---

一、消费型接口

消费型接口: Consumer< T> void accept(T t)有参数，无返回值的抽象方法

代码如下（示例）：

public class Cons {
    public static void main(String[] args) {
        // 消费性接口
//        Consumer<Person> consumer = new Consumer<Person>() {
//            @Override
//            public void accept(Person person) {
//                System.out.println(person.name);
//            }
//        };

        // lambda 表达式
        Consumer<Person> consumer = (person) -> {
            System.out.println(person.name);
        };

        consumer.accept(new Person());
    }
}

class Person {
    String name = "张三";
}

---

二、供给型接口

供给型接口: Supplier < T> T get() 无参有返回值的抽象方法

代码如下（示例）：

public class Supp {
    public static void main(String[] args) {
        // 供给型接口
//        Supplier<Person> supplier = new Supplier<Person>() {
//            @Override
//            public Person get() {
//                return new Person();
//            }
//        };
        
        Supplier<Person> supplier = () -> {
          return new Person();  
        };
        
        System.out.println(supplier.get().name);
    }
}

class Person {
    String name = "张三";
}

---

三、断定型接口

断定型接口: Predicate<T> boolean test(T t):有参，但是返回值类型是固定的boolean

代码如下（示例）：

public class Predi {
    public static void main(String[] args) {
        // 断定型接口
//        Predicate<Person> predicate = new Predicate<Person>() {
//            @Override
//            public boolean test(Person person) {
//                return false;
//            }
//        };
        
        Predicate<Person> predicate = (person) -> {
            return person.name.equals("张三");
        };
        
        
        System.out.println(predicate.test(new Person()));
    }
}


class Person {
    String name = "张三";
}

---

四、函数型接口

函数型接口: Function<T,R> R apply(T t)有参有返回值的抽象方法

代码如下（示例）：

public class Func {
    public static void main(String[] args) {
        // 函数型接口,<接受类型，返回类型>
//        Function<Person, String> function = new Function<Person, String>() {
//            @Override
//            public String apply(Person person) {
//                return person.toString();
//            }
//        };
        
        Function<Person, String> function = (person) -> {
            return person.name;
        };
        
        System.out.println(function.apply(new Person()));
    }
}


class Person {
    String name = "张三";
}

五、自定义函数式接口

代码如下（示例）：

@FunctionalInterface// 仅需在接口上加上该注解
public interface MyInterface {
    // 该方法是 public abstract 
    String doSth();// 内部只能有一个抽象方法
}


class T{
    public static void main(String[] args) {
//        MyInterface myInterface = new MyInterface() {
//            @Override
//            public String doSth() {
//                return null;
//            }
//        };

       MyInterface myInterface = () -> {
           return "doSth";
       };

        System.out.println(myInterface.doSth());

    }
}

总结

@FunctionalInterface为我们提供了函数式编程思想，即：我们只需要关心结果,不关心过程，以及谁来实现。每个调用者都可以编写自己的实现过程，来达到自己的目的。