java8新特性-函数式接口和默认方法

函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。
Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。
如定义了一个函数式接口如下：

@FunctionalInterface
interface GreetingService 
{
    void sayMessage(String message);
}

那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：

GreetingService greetService1 = message -> System.out.println("Hello " + message);

函数式接口可以对现有的函数友好地支持 lambda。
JDK 1.8 之前已有的函数式接口:
java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：
java.util.function

接口	描述
BiConsumer<T,U>	代表了一个接受两个输入参数的操作，并且不返回任何结果
BiFunction<T,U,R>	代表了一个接受两个输入参数的方法，并且返回一个结果
BinaryOperator< T >	代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
BiPredicate<T,U>	代表了一个两个参数的boolean值方法
BooleanSupplier	代表了boolean值结果的提供方
Consumer< T >	代表了接受一个输入参数并且无返回的操作
DoubleBinaryOperator	代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
DoubleConsumer	代表一个接受double值参数的操作，并且不返回结果.
DoubleFunction< R >	代表接受一个double值参数的方法，并且返回结果
DoublePredicate	代表一个拥有double值参数的boolean值方法
DoubleSupplier	代表一个double值结构的提供方
DoubleToIntFunction	接受一个double类型输入，返回一个int类型结果。
DoubleToLongFunction	接受一个double类型输入，返回一个long类型结果
DoubleUnaryOperator	接受一个参数同为类型double,返回值类型也为double 。
Function<T,R>	接受一个输入参数，返回一个结果。
IntBinaryOperator	接受两个参数同为类型int,返回值类型也为int 。
IntConsumer	接受一个int类型的输入参数，无返回值 。
IntFunction< R>	接受一个int类型输入参数，返回一个结果 。
IntPredicate	接受一个int输入参数，返回一个布尔值的结果。
IntSupplier	无参数，返回一个int类型结果。
IntToDoubleFunction	接受一个int类型输入，返回一个double类型结果 。
IntToLongFunction	接受一个int类型输入，返回一个long类型结果。
IntUnaryOperator	接受一个参数同为类型int,返回值类型也为int 。
LongBinaryOperator	接受两个参数同为类型long,返回值类型也为long。
LongConsumer	接受一个long类型的输入参数，无返回值。
LongFunction< R>	接受一个long类型输入参数，返回一个结果。
LongPredicate	R接受一个long输入参数，返回一个布尔值类型结果。
LongSupplier	无参数，返回一个结果long类型的值。
LongToDoubleFunction	接受一个long类型输入，返回一个double类型结果。
LongToIntFunction	接受一个long类型输入，返回一个int类型结果。
LongUnaryOperator	接受一个参数同为类型long,返回值类型也为long。
ObjDoubleConsumer< T>	接受一个object类型和一个double类型的输入参数，无返回值。
ObjIntConsumer< T>	接受一个object类型和一个int类型的输入参数，无返回值。
ObjLongConsumer< T>	接受一个object类型和一个long类型的输入参数，无返回值。
Predicate< T>	接受一个输入参数，返回一个布尔值结果。
Supplier< T>	无参数，返回一个结果。
ToDoubleBiFunction<T,U>	接受两个输入参数，返回一个double类型结果
ToDoubleFunction< T>	接受一个输入参数，返回一个double类型结果
ToIntBiFunction<T,U>	接受两个输入参数，返回一个int类型结果。
ToIntFunction< T>	接受一个输入参数，返回一个int类型结果。
ToDoubleBiFunction<T,U>	接受两个输入参数，返回一个long类型结果。。
ToLongFunction< T>	接受一个输入参数，返回一个long类型结果。
UnaryOperator< T>	接受一个参数为类型T,返回值类型也为T。

默认方法和静态方法

Java 8 新增了接口的默认方法。
简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。
我们只需在方法名前面加个 default 关键字即可实现默认方法。

为什么要有这个特性？
首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

接口中方法使用的注意事项
1、非default、static方法不能有实现，否则编译错误：Abstract methods do not specify a body
2、default、static方法必须有具体的实现，否则编译错误：This method requires a body instead of a semicolon
3、可以拥有多个default方法
4、可以拥有多个static方法
5、使用接口中类型时，仅仅需要实现抽象方法，default、static方法不需要强制自己新实现
6、static接口方法和类中的static方法特性一样。可以理解成只是命名空间上有差异。

语法
默认方法语法格式如下：

public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}

带来的问题

多个默认方法问题
一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法：

public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}
 
public interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}

第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：

public class Car implements Vehicle, FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮汽车!");
   }
}

第二种解决方案可以使用 super 来调用指定接口的默认方法：

public class Car implements Vehicle, FourWheeler {
   public void print(){
      Vehicle.super.print();
   }
}

继承抽象类同时实现接口引发的问题
接口实现默认方法sayHello

public interface DefaultStaticMethodDemo2 {
    default void sayHello(){
        System.out.println("hello");
    }
}

抽象类定义抽象方法sayHello

public abstract class AbstractClassDemo {

    public abstract void sayHello();
}

子类继承AbstractClassDemo 实现DefaultStaticMethodDemo2。
此时以继承优先，故子类必须实现抽象方法sayHello

public class SubClassDemo extends AbstractClassDemo implements DefaultStaticMethodDemo2{
    @Override
    public void sayHello() {

    }
}

参考：
https://www.runoob.com/java/java8-functional-interfaces.html
https://www.runoob.com/java/java8-default-methods.html