Java接口中的默认方法（Default Methods）

前言

在Java 8发布之后，接口的功能得到了显著增强，其中最引人注目的特性之一就是默认方法。默认方法允许接口提供带有实现的方法，这不仅不会破坏现有代码的兼容性，还能为所有实现了该接口的类直接提供新功能。

默认方法的基础知识

接口与抽象方法回顾

在Java中，接口是一种特殊的引用类型，它定义了一组行为规范，但不提供具体实现。任何实现了该接口的类都必须提供这些行为的具体实现。例如：

public interface MyInterface {
    void doSomething();
}

在这个例子中，doSomething是一个抽象方法，任何实现了MyInterface接口的类都必须提供这个方法的具体实现。

默认方法的引入

随着Java的发展，有时候我们想要给已有的接口添加新的功能，但又不想破坏现有的实现类。这时候，默认方法就派上用场了。默认方法允许我们在接口中定义具有默认实现的方法，这样即使没有显式覆盖，也能使用这些方法。默认方法使用default关键字来声明：

public interface MyInterface {
    // 抽象方法
    void doSomething();

    // 默认方法
    default void doAnotherThing() {
        System.out.println("This is a default method.");
    }
}

现在，任何实现了MyInterface接口的类都可以调用doAnotherThing()方法，而不需要额外的实现。

默认方法的作用

• 向后兼容性：可以在不改变现有代码的情况下为接口添加新方法。
• 减少重复代码：可以将公共逻辑放在接口级别，避免每个实现类都写相同的代码。
• 简化API设计：使得接口更加灵活，可以根据需要选择是否覆盖默认方法。

使用默认方法

创建并实现包含默认方法的接口

首先，让我们创建一个包含默认方法的接口，并展示如何在实现类中使用它。

// 定义接口
public interface MyInterface {
    void doSomething();

    default void doAnotherThing() {
        System.out.println("This is a default method from MyInterface.");
    }

    // 另一个默认方法
    default void greet() {
        System.out.println("Hello from MyInterface!");
    }
}

// 实现接口的类
public class MyClass implements MyInterface {

    @Override
    public void doSomething() {
        System.out.println("Doing something in MyClass.");
    }

    // 覆盖默认方法
    @Override
    public void greet() {
        System.out.println("Greetings from MyClass!");
    }

    // 可以不覆盖 doAnotherThing 方法，因为已经有了默认实现
}

调用默认方法

接下来，我们将创建MyClass的一个实例，并调用其方法来看看结果。

public class Main {
    public static void main(String[] args) {
        MyInterface myInstance = new MyClass();
        myInstance.doSomething();      // 输出: Doing something in MyClass.
        myInstance.doAnotherThing();   // 输出: This is a default method from MyInterface.
        myInstance.greet();            // 输出: Greetings from MyClass!
    }
}

如你所见，doAnotherThing方法直接使用了接口提供的默认实现，而greet方法则被MyClass类覆写了，因此输出的是覆写后的版本。

解决多重继承冲突

当一个类实现了多个接口时，如果这些接口中有同名的默认方法，就会出现冲突。此时，你需要在你的类中明确指定要使用哪个接口的默认方法，或者提供自己的实现。

interface InterfaceA {
    default void hello() {
        System.out.println("Hello from InterfaceA");
    }
}

interface InterfaceB {
    default void hello() {
        System.out.println("Hello from InterfaceB");
    }
}

class MyClass implements InterfaceA, InterfaceB {
    // 解决冲突，选择其中一个接口的方法或提供自己的实现
    @Override
    public void hello() {
        InterfaceA.super.hello(); // 显式调用InterfaceA的hello方法
        InterfaceB.super.hello(); // 显式调用InterfaceB的hello方法
    }
}

应用案例分析

字典服务接口的实际应用

这是若依框架中字典服务接口DictService，它提供了根据字典类型和值或标签获取相关信息的功能。这里我们简单介绍下如何利用默认方法来简化接口的设计。

import org.apache.commons.lang3.StringUtils;

public interface DictService {

    /**
     * 根据字典类型和字典值获取字典标签，默认使用分隔符。
     */
    default String getDictLabel(String dictType, String dictValue) {
        return getDictLabel(dictType, dictValue, StringUtils.SEPARATOR);
    }

    /**
     * 根据字典类型和字典标签获取字典值，默认使用分隔符。
     */
    default String getDictValue(String dictType, String dictLabel) {
        return getDictValue(dictType, dictLabel, StringUtils.SEPARATOR);
    }

    /**
     * 根据字典类型和字典值获取字典标签，指定分隔符。
     */
    String getDictLabel(String dictType, String dictValue, String separator);

    /**
     * 根据字典类型和字典标签获取字典值，指定分隔符。
     */
    String getDictValue(String dictType, String dictLabel, String separator);
}

在这个例子中，getDictLabel和getDictValue两个默认方法简化了调用者提供的参数数量，同时保持了灵活性，因为底层实现仍然支持自定义分隔符。这减少了调用者的负担，同时也确保了代码的一致性和可维护性。

实现DictService接口

为了使上述接口更有意义，我们可以创建一个简单的实现类，演示如何使用默认方法：

public class SimpleDictServiceImpl implements DictService {

    private final Map<String, Map<String, String>> dictionary;

    public SimpleDictServiceImpl(Map<String, Map<String, String>> dictionary) {
        this.dictionary = dictionary;
    }

    @Override
    public String getDictLabel(String dictType, String dictValue, String separator) {
        if (dictionary.containsKey(dictType)) {
            for (Map.Entry<String, String> entry : dictionary.get(dictType).entrySet()) {
                if (entry.getValue().equals(dictValue)) {
                    return entry.getKey();
                }
            }
        }
        return null; // 或者抛出异常，取决于业务需求
    }

    @Override
    public String getDictValue(String dictType, String dictLabel, String separator) {
        if (dictionary.containsKey(dictType)) {
            return dictionary.get(dictType).get(dictLabel);
        }
        return null; // 或者抛出异常，取决于业务需求
    }
}

在此实现中，我们假设有一个内部的字典数据结构，用来存储不同类型的字典条目。SimpleDictServiceImpl类提供了具体的实现，同时利用了DictService接口中定义的默认方法，简化了对外部用户的API。

默认方法的优点

1. 向后兼容性：可以在不破坏现有代码的情况下为接口添加新功能。
2. 方法复用：提供了一种在接口层面共享公共实现的方式，避免了重复代码。
3. 减少样板代码：对于一些常见的操作或辅助功能，可以将其直接放在接口中作为默认方法，从而减少每个实现类中相似的样板代码。
4. 提升灵活性：实现类可以选择是否覆盖默认方法，增强了设计上的灵活性。
5. 简化API设计：可以通过默认方法提供简洁的API，隐藏复杂的实现细节。

结论

默认方法是Java 8引入的一个重要特性，它增强了接口的功能，使接口更加灵活且易于扩展。通过理解并正确使用默认方法，开发者可以编写更简洁、更可维护的代码。