JDK 8 新特性之接口详解

怼烎@ 2024-03-27 08:55 39阅读 0赞

**目录**

一：接口新增的两个方法

接口默认方法的定义格式

接口默认方法的使用

二：接口静态方法

接口默认方法和静态方法的区别：

小结 ：

三：常用内置函数式接口

四：Supplier接口

五：Consumer接口

六：Function接口

七：Predicate接口

案例：

小结：

--------------------

## 一：**接口新增的两个方法** ##

JDK 8以前的接口：

interface 接口名 {
    静态常量;
    抽象方法;
    }

JDK 8 对接口的增强，接口还可以有 **默认方法** 和 **静态方法**

JDK 8的接口：

interface 接口名 {
    静态常量;
    抽象方法;
    默认方法;
    静态方法;
    }

> **接口引入默认方法的背景**

在 JDK 8 以前接口中只能有抽象方法。存在以下问题：

如果给接口新增抽象方法，所有实现类都必须重写这个抽象方法。不利于接口的扩展。

interface A {
    public abstract void test1();
    // 接口新增抽象方法,所有实现类都需要去重写这个方法,非常不利于接口的扩展
    public abstract void test2();
    }
    class B implements A {
    @Override
    public void test1() {
    System.out.println("BB test1");
    }
    // 接口新增抽象方法,所有实现类都需要去重写这个方法
    @Override
    public void test2() {
    System.out.println("BB test2");
    }
    }
    class C implements A {
    @Override
    public void test1() {
    System.out.println("CC test1");
    }
    // 接口新增抽象方法,所有实现类都需要去重写这个方法
    @Override
    public void test2() {
    System.out.println("CC test2");
    }
    }

例如， JDK 8  时在 Map 接口中增加了  forEach  方法：

public interface Map<K, V> {
    ...
    abstract void forEach(BiConsumer<? super K, ? super V> action);
    }

通过 API 可以查询到 Map 接口的实现类如：

Interface Map<K， V>
    所有已知实现类：
    AbstractMap，ConcurrentSkipListMap，IdentityHashMap，MapPropertyBase，Provider，Rendering Hints，SimpleMapProperty，Attributes，ReadonlyMapProperty，AuthProvider，EnumMapHashMap，
    clipboardContent，Hashtable，SimpleBindings，TreeMap，ConcurrentHashMap，MapProperty，
    ReadOnlyMapWrapper，Headers.Properties，LinkedHashMap，MultiMap Result，ScriptObjectMirror，
    TabularDataSupport，MapBinding，MapExpression，PrinterStateReasons，ReadonlyMapPropertyBase，UIDefaults，WeakHashMap

如果在 Map 接口中增加一个抽象方法，所有的实现类都需要去实现这个方法，那么工程量时巨大的。

因此，在 JDK 8 时为接口新增了默认方法，效果如下：

public interface Map<K, V> {
    ...
    default void forEach(BiConsumer<? super K, ? super V> action) {
    ...
    }
    }

接口中的默认方法实现类不必重写，可以直接使用，实现类也可以根据需要重写。这样就方便接口的扩展。

> #### **接口默认方法的定义格式** ####

interface 接口名 {
    修饰符 default 返回值类型 方法名() {
    代码;
    }
    }

> #### **接口默认方法的使用**  ####

方式一：实现类直接调用接口默认方法

方式二：实现类重写接口默认方法

public class Demo02UserDefaultFunction {
    public static void main(String[] args) {
    BB b = new BB();
    // 方式一：实现类直接调用接口默认方法
    b.test02();
    CC c = new CC();
    // 调用实现类重写接口默认方法
    c.test02();
    }
    }
    interface AA {
    public abstract void test1();
    public default void test02() {
    System.out.println("AA test02");
    }
    }
    class BB implements AA {
    @Override
    public void test1() {
    System.out.println("BB test1");
    }
    }
    class CC implements AA {
    @Override
    public void test1() {
    System.out.println("CC test1");
    }
    // 方式二：实现类重写接口默认方法
    @Override
    public void test02() {
    System.out.println("CC实现类重写接口默认方法");
    }
    }

## 二：**接口静态方法**  ##

为了方便接口扩展， JDK 8 为接口新增了静态方法。

> 接口静态方法的定义格式

interface 接口名 {
    修饰符 static 返回值类型 方法名() {
    代码;
    }
    }

> 接口静态方法的使用

直接使用接口名调用即可：接口名. 静态方法名 ();

public class Demo04UseStaticFunction {
    public static void main(String[] args) {
    // 直接使用接口名调用即可：接口名.静态方法名();
    AAA.test01();
    }
    }
    interface AAA {
    public static void test01() {
    System.out.println("AAA 接口的静态方法");
    }
    }
    class BBB implements AAA {
    /* @Override 静态方法不能重写
    public static void test01() {
    System.out.println("AAA 接口的静态方法");
    }*/
    }

#### **接口默认方法和静态方法的区别：** ####

1.  默认方法通过实例调用，静态方法通过接口名调用。

2.  默认方法可以被继承，实现类可以直接使用接口默认方法，也可以重写接口默认方法。

3.  静态方法不能被继承，实现类不能重写接口静态方法，只能使用接口名调用。

#### **小结** ： ####

**接口中新增的两种方法：**

默认方法和静态方法

如何选择呢？

如果这个方法需要被实现类继承或重写，使用默认方法，如果接口中的方法不需要被继承就使用静态方法

## 三：**常用内置函数式接口**  ##

> **内置函数式接口来由来**

我们知道使用 Lambda 表达式的前提是需要有函数式接口。而 Lambda 使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda 方便， JDK 提供了大量常用的函数式接口。

import java.util.List;
    public class Demo01UserFunctionalInterface {
    public static void main(String[] args) {
    // 调用函数式接口中的方法
    method((arr) -> {
    int sum = 0;
    for (int n : arr) {
    sum += n;
    }
    return sum;
    });
    }
    // 使用自定义的函数式接口作为方法参数
    public static void method(Operator op) {
    int[] arr = {1, 2, 3, 4};
    int sum = op.getSum(arr);
    System.out.println("sum = " + sum);
    }
    }
    @FunctionalInterface
    interface Operator {
    public abstract int getSum(int[] arr);
    }

> **常用内置函数式接口介绍**

它们主要在  java.util.function  包中。下面是最常用的几个接口。

1. Supplier 接口

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

2. Consumer 接口

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

3. Function 接口

@FunctionalInterface
    public interface Function<T, R> {
    public abstract R apply(T t);
    }

4. Predicate 接口

@FunctionalInterface
    public interface Predicate<T> {
    public abstract boolean test(T t);
    }
    Predicate接口用于做判断,返回boolean类型的值

## 四：**Supplier****接口** ##

java.util.function.Supplier<T>  接口，它意味着 " 供给 " ,  对应的 Lambda 表达式需要 “ **对外提供** ” 一个符合泛型类型的对象数据。

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

供给型接口，通过 Supplier 接口中的 get 方法可以得到一个值，无参有返回的接口。

**使用** **Lambda** **表达式返回数组元素最大值**

使用  Supplier  接口作为方法参数类型，通过 Lambda 表达式求出 int 数组中的最大值。提示：接口的泛型请使用 java.lang.Integer 类。

**代码示例** **:**

public class Demo05Supplier {
    public static void main(String[] args) {
    printMax(() -> {
    int[] arr = {10, 20, 100, 30, 40, 50};
    // 先排序,最后就是最大的
    Arrays.sort(arr);
    return arr[arr.length - 1]; // 最后就是最大的
    });
    }
    private static void printMax(Supplier<Integer> supplier) {
    int max = supplier.get();
    System.out.println("max = " + max);
    }
    }

## 五：**Consumer****接口**  ##

java.util.function.Consumer<T>  接口则正好相反，它不是生产一个数据，而是 **消费** 一个数据，其数据类型由泛型参数决定。

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

**使用** **Lambda** **表达式将一个字符串转成大写和小写的字符串**

Consumer 消费型接口，可以拿到 accept 方法参数传递过来的数据进行处理 ,  有参无返回的接口。基本使用如：

import java.util.function.Consumer;
    public class Demo06Consumer {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    System.out.println(s.toLowerCase());
    });
    }
    public static void test(Consumer<String> consumer) {
    consumer.accept("HelloWorld");
    }
    }

**默认方法：** **andThen**

如果一个方法的参数和返回值全都是  Consumer  类型，那么就可以实现效果：消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer  接口中 default 方法  andThen 。 下面是 JDK 的源代码：

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

备注：  java.util.Objects  的  requireNonNull  静态方法将会在参数为 null 时主动抛出NullPointerException 异常。这省去了重复编写 if 语句和抛出空指针异常的麻烦。

要想实现组合，需要两个或多个 Lambda 表达式即可，而  andThen  的语义正是 “ 一步接一步 ” 操作。例如两个步骤组合的情况：

public class Demo07ConsumerAndThen {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    System.out.println(s.toLowerCase());
    }, (String s) -> {
    System.out.println(s.toUpperCase());
    });
    // Lambda表达式简写
    test(s -> System.out.println(s.toLowerCase()), s ->
    System.out.println(s.toUpperCase()));
    }
    public static void test(Consumer<String> c1, Consumer<String > c2) {
    String str = "Hello World";
    // c1.accept(str); // 转小写
    // c2.accept(str); // 转大写
    // c1.andThen(c2).accept(str);
    c2.andThen(c1).accept(str);
    }
    }

运行结果将会首先打印完全大写的 HELLO ，然后打印完全小写的 hello 。当然，通过链式写法可以实现更多步骤的组合。

## 六：**Function****接口** ##

java.util.function.Function<T,R>  接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值

@FunctionalInterface
    public interface Function<T, R> {
    public abstract R apply(T t);
    }

**使用** **Lambda** **表达式将字符串转成数字**

Function 转换型接口，对 apply 方法传入的 T 类型数据进行处理，返回 R 类型的结果，有参有返回的接口。使用的场景

例如：将  String  类型转换为  Integer  类型。

public class Demo08Function {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    return Integer.parseInt(s); // 10
    });
    }
    public static void test(Function<String, Integer> function) {
    Integer in = function.apply("10");
    System.out.println("in: " + (in + 5));
    }
    }

**默认方法：** **andThen**

Function  接口中有一个默认的  andThen  方法，用来进行组合操作。 JDK 源代码如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
    }

该方法同样用于 “ 先做什么，再做什么 ” 的场景，和  Consumer  中的  andThen  差不多：

public class Demo09FunctionAndThen {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    return Integer.parseInt(s);
    }, (Integer i) -> {
    return i * 10;
    });
    }
    public static void test(Function<String, Integer> f1, Function<Integer, Integer> f2) {
    // Integer in = f1.apply("66"); // 将字符串解析成为int数字
    // Integer in2 = f2.apply(in);// 将上一步的int数字乘以10
    Integer in3 = f1.andThen(f2).apply("66");
    System.out.println("in3: " + in3); // 660
    }
    }

第一个操作是将字符串解析成为 int 数字，第二个操作是乘以 10 。两个操作通过  andThen  按照前后顺序组合到了一 起。

请注意， Function 的前置条件泛型和后置条件泛型可以相同。

##  ##

## 七：**Predicate****接口**  ##

有时候我们需要对某种类型的数据进行判断，从而得到一个 boolean 值结果。这时可以使用 java.util.function.Predicate<T> 接口。

@FunctionalInterface
    public interface Predicate<T> {
    public abstract boolean test(T t);
    }
    Predicate接口用于做判断,返回boolean类型的值

**使用** **Lambda** **判断一个人名如果超过** **3** **个字就认为是很长的名字**

对 test 方法的参数 T 进行判断，返回 boolean 类型的结果。用于条件判断的场景：

public class Demo10Predicate {
    public static void main(String[] args) {
    test(s -> s.length() > 3, "迪丽热巴");
    }
    private static void test(Predicate<String> predicate, String str) {
    boolean veryLong = predicate.test(str);
    System.out.println("名字很长吗：" + veryLong);
    }
    }

条件判断的标准是传入的 Lambda 表达式逻辑，只要名称长度大于 3 则认为很长。

**默认方法：** **and**

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个  Predicate  条件使用 “ 与 ” 逻辑连接起来实现“ **并且** ” 的效果时，可以使用 default 方法  and  。其 JDK 源码为：

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
    }

#### 案例： ####

*  **使用****Lambda****表达式判断一个字符串中即包含****W,****也包含****H** 
 *  **使用****Lambda****表达式判断一个字符串中包含****W****或者包含****H** 
 *  **使用****Lambda****表达式判断一个字符串中即不包含****W**

如果要判断一个字符串既要包含大写 “H” ，又要包含大写 “W” ，那么：

public class Demo10Predicate_And_Or_Negate {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    return s.contains("H");
    }, (String s) -> {
    return s.contains("W");
    });
    }
    public static void test(Predicate<String> p1, Predicate<String> p2) {
    String str = "HelloWorld";
    boolean b1 = p1.test(str); // 判断包含大写“H”
    boolean b2 = p2.test(str); // 判断包含大写“W”
    // if (b1 && b2) {
    // System.out.println("即包含W,也包含H");
    // }
    boolean bb = p1.and(p2).test(str);
    if (bb) {
    System.out.println("即包含W,也包含H");
    }
    }
    }

**默认方法：** **or**

**使用** **Lambda** **表达式判断一个字符串中包含** **W** **或者包含** **H**

与  and  的 “ 与 ” 类似，默认方法  or  实现逻辑关系中的 “ **或** ” 。 JDK 源码为：

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
    }

如果希望实现逻辑 “ 字符串包含大写 H 或者包含大写 W” ，那么代码只需要将 “and” 修改为 “or” 名称即可，其他都不变：

public class Demo10Predicate_And_Or_Negate {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    return s.contains("H");
    }, (String s) -> {
    return s.contains("W");
    });
    }
    public static void test(Predicate<String> p1, Predicate<String> p2) {
    String str = "HelloWorld";
    boolean b1 = p1.test(str); // 判断包含大写“H”
    boolean b2 = p2.test(str); // 判断包含大写“W”
    // if (b1 || b2) {
    // System.out.println("有H,或者W");
    // }
    boolean bbb = p1.or(p2).test(str);
    if (bbb) {
    System.out.println("有H,或者W");
    }
    }
    }

**默认方法：** **negate**

**使用** **Lambda** **表达式判断一个字符串中即不包含** **W**

“ 与 ” 、 “ 或 ” 已经了解了，剩下的 “ 非 ” （取反）也会简单。默认方法  negate  的 JDK 源代码为：

default Predicate<T> negate() {
    return (t) -> !test(t);
    }

从实现中很容易看出，它是执行了 test 方法之后，对结果 boolean 值进行 “!” 取反而已。一定要在  test  方法调用之前调用 negate  方法，正如  and  和  or  方法一样：

import java.util.function.Predicate;
    public class Demo10Predicate_And_Or_Negate {
    public static void main(String[] args) {
    // Lambda表达式
    test((String s) -> {
    return s.contains("H");
    }, (String s) -> {
    return s.contains("W");
    });
    }
    public static void test(Predicate<String> p1, Predicate<String> p2) {
    String str = "HelloWorld";
    boolean b1 = p1.test(str); // 判断包含大写“H”
    boolean b2 = p2.test(str); // 判断包含大写“W”
    // 没有H,就打印
    // if (!b1) {
    // System.out.println("没有H");
    // }
    boolean test = p1.negate().test(str);
    if (test) {
    System.out.println("没有H");
    }
    }
    }

#### **小结：** ####

1. Supplier 接口

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

2. Consumer 接口

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

3. Function 接口

@FunctionalInterface
    public interface Function<T, R> {
    public abstract R apply(T t);
    }

4. Predicate 接口

@FunctionalInterface
    public interface Predicate<T> {
    public abstract boolean test(T t);
    }
    Predicate接口用于做判断,返回boolean类型的值