JDK1.8新特性——接口改动和Lambda表达式

JDK1.8新特性——接口改动和Lambda表达式

摘要：本文主要学习了JDK1.8的新特性中有关接口和Lambda表达式的部分。

部分内容来自以下博客：

https://www.cnblogs.com/onetwo/p/8526374.html

https://www.cnblogs.com/xxez-d/p/5989944.html

https://www.cnblogs.com/runningTurtle/p/7092632.html

https://www.cnblogs.com/jiangwz/p/9197238.html

https://www.cnblogs.com/hujingnb/p/10181630.html

接口增强

在JDK1.8以前的版本中，定义一个接口时，所有的方法必须是抽象方法，不能有具体实现，这是Java语法规定的。但是在JDK1.8中定义一个接口时，在满足特定的前提下，可以有方法的具体实现。这样一个接口中可以有属性，可以有抽象方法，也可以有具体的方法，这跟JDK1.8以前的接口比，明显接口的功能变得强大了。

使用接口增强

接口中定义具体的方法实现是有限制的，它不能像我们在一个普通类那样随便定义方法实现，它只能定义default和static类型的方法。

在调用的时候，被default修饰的默认方法需要通过实现了该接口的类去调用，被static修饰的静态方法可以通过接口名直接调用。

default和static不能用来修饰Object中的public方法，但是可以修饰Object中其他访问修饰符修饰的方法。

代码如下：

public class Demo {
    public static void main(String[] args) {
        NewInterface.testStatic();
        new NewInterfaceImpl().testDefault();
    }
}

interface NewInterface {
    public String name = "";
    
    default void testDefault() {
        System.out.println("测试新增的default方法");
    }
    
    static void testStatic() {
        System.out.println("测试新增的static方法");
    }
}

class NewInterfaceImpl implements NewInterface {
    @Override
    public void testDefault() {
        NewInterface.super.testDefault();
        System.out.println("测试子类重写的新增的static方法");
    }
}

运行结果如下：

测试新增的static方法
测试新增的default方法
测试子类重写的新增的static方法

好处

想象这样一中情况，当多个类实现一个接口的某个方法时，方法的具体实现代码相同，这样就会造成代码重复问题。接口增强就相当于把公共的代码抽离出来，放入接口定义中，这样实现类对于该方法就不用重新定义，直接调用即可，这很好的解决了实现该接口的子类代码重复的问题。

函数式接口

所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法，这种类型的接口也称为SAM（Single Abstract Method）接口。

下面的代码展示了一个简单的函数式接口：

interface NewInterface {
    void test();
}

关于@FunctionalInterface注解

JDK1.8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。

加不加@FunctionalInterface对于接口是不是函数式接口没有影响，该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。

下面的代码展示了一个加了注解的函数式接口：

@FunctionalInterface
interface NewInterface {
    void test();
}

函数式接口里允许定义默认方法

函数式接口里是可以包含默认方法，因为默认方法不是抽象方法，其有一个默认实现，所以是符合函数式接口的定义的。

下面的代码展示了一个带有默认方法的函数式接口：

@FunctionalInterface
interface NewInterface {
    void test();
    
    default void defaultRead() {
        System.out.println("defaultRead() ...");
    }
    
    default void defaultWrite() {
        System.out.println("defaultWrite() ...");
    }
}

函数式接口里允许定义静态方法

函数式接口里是可以包含静态方法，因为静态方法不能是抽象方法，是一个已经实现了的方法，所以是符合函数式接口的定义的。

下面的代码展示了一个带有静态方法的函数式接口：

@FunctionalInterface
interface NewInterface {
    void test();
    
    static void staticRead() {
        System.out.println("staticRead() ...");
    }
    
    static void staticWrite() {
        System.out.println("staticWrite() ...");
    }
}

函数式接口里允许定义java.lang.Object里的public方法

函数式接口里是可以包含Object里的public方法，这些方法对于函数式接口来说，不被当成是抽象方法（虽然它们是抽象方法）。因为此接口的实现类一定是Object的子类，会自动实现这个接口中定义的抽象方法。

但也只能是public方法，其他访问修饰符修饰的方法是不允许在函数式接口里定义的。

下面的代码展示了一个带有Object类的public方法的函数式接口：

@FunctionalInterface
interface NewInterface {
    void test();
    
    @Override
    public String toString();
    
    @Override
    public boolean equals(Object obj);
    
//    @Override
//    public Object clone();
}

JDK1.8新增的函数式接口

JDK1.8内置的函数式接口放在包java.util.function下，默认在JDK安装路径下的src.zip中。

Supplier接口

Supplier接口没有参数，只有返回值，作用是为了产生对象。

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

Consumer接口

Consumer接口有参数，但是没有返回值，作用是为了进行某种操作，比如打印操作。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Function接口

Function接口有参数，也有返回值，作用是对参数进行处理并返回。

@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;
    }
}

Predicate接口

Predicate接口有参数，也有返回值，但返回值是Boolean类型的值，作用是对传入的参数进行某种判断。

@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);
    }
}

Lambda表达式

什么是Lambda表达式

通过使用表达式来提供一种清晰简洁的方式来表示方法接口。

语法

参数列表 -> 方法体

如果参数列表有多个值，可以使用小括号包含，如果只有一条，则可以省略小括号。

如果方法体有多条语句，可以使用大括号包含，如果只有一条，则可以省略大括号，如果是return语句，则可以省略return关键字。

使用举例

在创建一个线程并调用的时候，需要传入一个Runnable接口的实现类。

使用Lambda表达式之前：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread1 run() ...");
    }
}).start();

使用Lambda表达式之后：

new Thread(() -> System.out.println("Thread2 run() ...")).start();

变量作用域

Lambda表达式只能引用标记了final的外层局部变量，这就是说不能在Lambda内部修改定义在域外的局部变量，否则会编译错误。

final int num = 100;
NewInterface ni = i -> String.valueOf(i + num);
System.out.println(ni.test(num));

Lambda表达式的局部变量可以不用声明为final，但是必须不可被后面的代码修改（即隐性的具有final的语义）。

final int num = 100;
NewInterface ni = i -> String.valueOf(i + num);
System.out.println(ni.test(num));
// num++;

在Lambda表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

final int num = 100;
// NewInterface ni = num -> String.valueOf(num);
NewInterface ni = i -> String.valueOf(i);
System.out.println(ni.test(num));

方法引用

什么是方法引用

方法引用是JDK1.8中提出的用来简化Lambda表达式的一种手段。它通过类名和方法名来定位到一个静态方法或者实例方法。

语法

类或对象名::方法名或new

静态方法引用

如果是静态方法引用，那么语法是 类名::静态方法名 ，并且方法调用传入的参数就是方法用到的参数。

代码如下：

public class Demo {
    public static void main(String[] args) {
        // 使用匿名内部类
//        NewInterface ni = new NewInterface() {
//            @Override
//            public String test(String name) {
//                return String.valueOf(name);
//            }
//        };
        // 使用Lambda表达式
//        NewInterface ni = name -> String.valueOf(name);
        // 使用方法引用
        NewInterface ni = String::valueOf;
        System.out.println(ni.test("name"));
    }
}

@FunctionalInterface
interface NewInterface {
    String test(String name);
}

运行结果如下：

name

实例方法引用

如果是实例方法引用，那么语法是 对象实例::方法名 ，并且方法调用传入的第一个参数是方法的调用者，后面的参数才是方法的参数。

代码如下：

public class Demo {
    public static void main(String[] args) {
        // 使用匿名内部类
//        NewInterface ni = new NewInterface() {
//            @Override
//            public int test(String str) {
//                return str.length();
//            }
//        };
        // 使用Lambda表达式
//        NewInterface ni = str -> str.length();
        // 使用方法引用
        NewInterface ni = String::length;
        System.out.println(ni.test("lenth"));
    }
}

@FunctionalInterface
interface NewInterface {
    int test(String str);
}

运行结果如下：

5

构造方法引用

如果是构造方法引用，那么语法是 类名::new ，并且方法调用传入的参数就是构造方法的参数。

代码如下：

public class Demo {
    public static void main(String[] args) {
        // 使用匿名内部类
//        NewInterface ni = new NewInterface() {
//            @Override
//            public String test(String str) {
//                return new String(str);
//            }
//        };
        // 使用Lambda表达式
//        NewInterface ni = str -> new String(str);
        // 使用方法引用
        NewInterface ni = String::new;
        System.out.println(ni.test("str"));
    }
}

@FunctionalInterface
interface NewInterface {
    String test(String str);
}

运行结果如下：

str