【Java8 新特性 2】函数式接口 + Lamda表达式推导过程

爱被打了一巴掌 2021-08-30 11:27 367阅读 0赞

## 一、函数式接口简介 ##

函数式接口是 Java8 引入的一个新特性，是一种特殊的接口：SAM类型的接口（Single Abstract Method），但本质上还是接口。相比较于其他接口，函数式接口有且只能有一个抽象方法。只要接口中出现多个抽象方法，那么就不能称之为函数式接口，运行的时候就会报错。为此 Java8 提供了一个新的注解`@FunctionalInterface`，如果接口被这个注解标注，就说明该接口是函数式接口，如果有多于一个的抽象方法，在编译的时候就会报错。但是这个注解不是必需的，只要接口符合函数式接口的定义，那么这个接口就是函数式接口。

简单来说，一个接口有且只有一个抽象方法，即函数式接口。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1][]

## 二、函数式接口特性 ##

原则上讲，函数式接口中有且只能有一个抽象方法。但是在 Java8 之后接口中也是可以定义方法的：默认方法和静态方法，这两种方法的定义并不会影响函数式接口的定义，可以随意使用。即：

### 1、静态方法 ###

接口中可以有一个或多个静态方法，这不会影响到函数式接口的定义。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3][]

### 2、default方法 ###

在 Java8 之后，接口允许定义由 default 修饰的默认方法，并且不强制实现类重写此方法，这些方法也不会影响到函数式接口的定义。

默认方法不能被直接调用，可以由实现类调用。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 4][]

注意事项

（1）当一个实现类实现了多个接口，多个接口里都有相同的默认方法时，实现类必须重写该默认方法，否则编译错误。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 5][]

（2）实现类使用super关键字指定使用哪个接口的默认方法。

### 3、函数式接口支持继承 ###

函数式接口支持继承，可以继承多个父接口，但是每个父接口只能有一个抽象方法，且必须是相同的抽象方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 6][]

## 三、函数式接口的意义 ##

我是这么理解的，java是面向对象的，但是为了写起来方便，需要向一个方法传递一个方法，但是实际上并不能传递方法，而是传递了只有一个抽象方法的接口的实现类的对象，这样就做到类似传递方法了，其实lanmada就是一个对象

## 四、四种核心的函数式接口 ##

### 1、功能性接口Function   ###

接收一个功能参数t，并返回一个功能结果R。

package java.util.function;
    import java.util.Objects;
     
     
    @FunctionalInterface
    public interface Function<T, R> {
     
        R apply(T t);
     
        default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }
     
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }
     
        static <T> Function<T, T> identity() {
            return t -> t;
        }
    }

### 2、断言性接口：Predicate ###

主要用到test方法** **其中参数t为输入参数，如果输入参数符合断言则返回true，否则false

package java.util.function;
    import java.util.Objects;
    @FunctionalInterface
    public interface Predicate<T> {
     
        boolean test(T t);
     
        default Predicate<T> and(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }
     
        default Predicate<T> negate() {
            return (t) -> !test(t);
        }
     
        default Predicate<T> or(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }
     
        static <T> Predicate<T> isEqual(Object targetRef) {
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
        }
    }

### 3、供给性接口：Supplier ###

**不接收任何参数 但有返回值**

@FunctionalInterface
    public interface Supplier<T> {
     
        T get();
    }

### 4、消费性接口：Consumer    ###

只接收一个参数t，但是没有返回值。

## 五、Lambda表达式 ##

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。**Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。**

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

简单明了，函数式接口就是为了Lambda 表达式而生的。

## 六、Lambda表达式的推导过程 ##

![20200702171826709.gif][]

### 1、匿名内部类 --> Lambda表达式 --> 简化Lambda表达式 ###

package java8.lamda;
    
    public class LamdaTest {
        public static void main(String[] args) {
            //匿名内部类
            IStudent student = new IStudent() {
                @Override
                public void study(String technology,int time) {
                    System.out.println("匿名内部类,"+technology+time);
                }
            };
            student.study("java",8);
    
            //Lambda表达式改造（将类名和方法名去掉）
            IStudent student1 = (String technology,int time)->{
                System.out.println("Lambda表达式改造（将类名和方法名去掉）"+technology+time);
            };
            student1.study("java",8);
    
            //一级进化（去掉数据类型）
            IStudent student2 = ((technology, time) -> {
                System.out.println("一级进化（去掉数据类型）"+technology+time);
            });
            student2.study("java",8);
    
            //二级进化（简化括号）,一般进行一次进化就可以了，二级进化没必要
            IStudent student3 = ((technology, time) -> System.out.println("二级进化（简化括号）"+technology+time));
            student3.study("java",8);
        }
    }
    
    @FunctionalInterface
    interface IStudent {
        void study(String technology,int time);
    }

### 2、控制台输出 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 7][]

上一篇：[Java注解深入浅出][Java]

下一篇：[【Java8 新特性】Lambda表达式总结（全栈最强，绝对豪横）][Java8 _Lambda]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70]: /images/20210813/d1e55858bc674ac58a6142d8d9a30398.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1]: /images/20210813/6e9410d17eda4d2b962101707d8991f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2]: /images/20210813/5b68acd025524ad4ac2c3107becdff59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3]: /images/20210813/992557c1abab4f3790d6f842e4f0613c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 4]: /images/20210813/85ddc4e18d8f44a8b4f1a97d1003c635.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 5]: /images/20210813/451b2d37f96d4ddfa27f112a8864fc3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 6]: /images/20210813/6d47b6f71dce443e9092c10ca6d7be3f.png
[20200702171826709.gif]: /images/20210813/3684b9cfc33a4f2aa75e3ec34bc23a30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 7]: /images/20210813/3e16749a6f274e2190df3e3edbb4d810.png
[Java]: https://blog.csdn.net/guorui_java/article/details/106658179
[Java8 _Lambda]: https://blog.csdn.net/guorui_java/article/details/106996651