函数式接口、默认方法和Optional类

函数式接口

函数式接口通过一个单一的功能来表现。例如，带有单个compareTo方法的比较接口，被用于比较的场合。Java 8 开始定义了大量的函数式接口来广泛地用于lambda表达式。

Java 8 引入的一个核心概念是函数式接口（Functional Interfaces）。通过在接口里面添加一个抽象方法，这些方法可以直接从接口中运行。如果一个接口定义唯一一个抽象方法，那么这个接口就成为函数式接口。同时，引入了一个新的注解：@FunctionalInterface。可以把他它放在一个接口前，表示这个接口是一个函数式接口。这个注解是非必须的，只要接口只包含一个方法的接口，虚拟机会自动判断，不过最好在接口上使用注解 @FunctionalInterface 进行声明。在接口中添加了 @FunctionalInterface 的接口，只允许有一个抽象方法，否则编译器也会报错。引用自IBM - Java 8 新特性概述

相关的接口及描述

下面是部分函数式接口的列表

更多的接口可以参考Java官方API手册：java.lang.Annotation Type FunctionalInterface。在实际使用过程中，加有 @FunctionalInterface 注解的方法均是此类接口，位于java.util.Funtion包中。

一个函数式编程的例子

下面我们通过一个例子学习如何使用这些函数式编程的接口

新建一个类 NewFeaturesTester.java，以下是 NewFeaturesTester.java 类中应当输入的代码：

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class NewFeaturesTester {
   public static void main(String args[]){
      List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

      System.out.println("All of the numbers:");

      eval(list, n->true);

      System.out.println("Even numbers:");
      eval(list, n-> n%2 == 0 );

      System.out.println("Numbers that greater than  5:");
      eval(list, n -> n > 5 );
   }

   public static void eval(List<Integer> list, Predicate<Integer> predicate) {
      for(Integer n: list) {

         if(predicate.test(n)) {
            System.out.println(n);
         }
      }
   }
}

默认方法

Java 8在接口方面引入了一个关于默认方法实现的新概念。它也是作为一种向后兼容能力而出现，旧的接口也能用到Lambda表达式中。例如，List或 Collection 接口是没有forEach方法的声明的。但是，通过这些默认方法能够就能轻易地打破集合框架实现的限制。Java 8引入默认方式使得 List 和 Collection 接口能够拥有 forEach 方法的默认实现。实现了这些接口的类也不必再实现相同的功能了。

语法如下所示:

本段代码是示例代码,仅供理解使用。

public interface boy {
    default void print(){
        System.out.println("I am a boy");
    }
}

多个默认值

接口中有了默认方法之后，在同一个类里面实现两个带有相同默认方法的接口就可行了。

下面的代码演示了如何解决这种含糊不清的情况。

首先是同一个类里面的两个接口

本段是示例代码，仅供理解

public interface younger {
    default void print(){
        System.out.println("I am a younger.");
    }
}

public interface learner {
    default void print(){
        System.out.println("I am a learner.");
    }
}

第一个解决办法就是创建一个自有的办法，来重写默认的实现。就像这样：

本段代码是示例代码，仅供理解使用。

public class student implements younger, learner {
   public void print(){
      System.out.println("I am a younger and a learner, so I am  a student.");
   }
}

另一个解决办法就是使用超类 super 来调用特定接口的默认方法。

本段代码是示例代码，仅供理解使用

public class student implements younger, learner {
    public void print(){
        learner.super.print();
    }
}

静态默认方法

你也可以为这个接口增加静态的辅助方法(helper), 就像下面这样：

本段代码是示例代码，仅供理解使用

public interface Younger {
    default void print(){
        System.out.println("I am a younger.");
    }

    static void sayHi(){
        System.out.println("Young is the capital.");
    }
}

一个默认方法的例子

下面我们通过一个例子来掌握如何使用默认方法。请看下面的代码

public class NewFeaturesTester {
    public static void main(String args[]) {
        Younger younger = new Student();
        younger.print();
    }
}

interface Younger {
    default void print() {
        System.out.println("I am a younger.");
    }

    static void sayHi() {
        System.out.println("Young is the capital.");
    }
}

interface Learner {
    default void print() {
        System.out.println("I am a learner.");
    }
}

class Student implements Younger, Learner {
    public void print() {
        Younger.super.print();
        Learner.super.print();
        Younger.sayHi();
        System.out.println("I am a student!");
    }
}

Optional 类

Optional是一个容器对象，用于容纳非空对象。Optional对象通过缺失值值代表null。这个类有许多实用的方法来促使代码能够处理一些像可用或者不可用的值，而不是检查那些空值（null）。Java 8中引入的这个特性有点像Google Guava里的Optional（Guava 是一个 Google 的基于Java 6的类库集合的扩展项目）。

在Java官方文档的解释中，它是一个可以为null的容器对象。如果值存在则 isPresent() 方法会返回 true ，调用 get()方法会返回该对象。

类的声明及方法

下面是java.util.Optional<T>类的声明：

public final class Optional<T>
extends Object

这个类继承了java.lang.Object类大多数方法。主要有：

更多的你可以访问官方API手册查看：http://docs.oracle.com/javase/8/docs/api/java/util/Optional.html

一个Optional类的例子

import java.util.Optional;

public class NewFeaturesTester {
   public static void main(String args[]){

      NewFeaturesTester tester = new NewFeaturesTester();
      Integer value1 = null;
      Integer value2 = new Integer(5);

      // ofNullable 允许传参时给出 null
      Optional<Integer> a = Optional.ofNullable(value1);

      // 如果传递的参数为null，那么 of 将抛出空指针异常（NullPointerException）
      Optional<Integer> b = Optional.of(value2);
      System.out.println(tester.sum(a,b));
   }

   public Integer sum(Optional<Integer> a, Optional<Integer> b){

      // isPresent 用于检查值是否存在

      System.out.println("First parameter is present: " + a.isPresent());
      System.out.println("Second parameter is present: " + b.isPresent());

      // 如果当前返回的是传入的默认值，orElse 将返回它
      Integer value1 = a.orElse(new Integer(0));

      // get 用于获得值，条件是这个值必须存在
      Integer value2 = b.get();
      return value1 + value2;
   }
}

扩展阅读

Java 8 Optional类深度解析

参考链接

• Java SE 8: Lambda Quick Start
• The Java™ Tutorials - Default Methods