探索Java接口的进化：Java 8与Java 9的深入探讨

在Java 8中，接口得到了一次重要的升级，增加了一些新的特性，从而增强了接口的功能性和灵活性。以下是Java 8中接口的新特性：

1. 默认方法 (Default Methods)

在Java 8中，接口允许你定义带有实现的方法，称为默认方法。这意味着现有的接口可以添加新方法，而不会打破实现这些接口的现有类的代码。

例子：

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

    void normalMethod();
}

class MyClass implements MyInterface {
    @Override
    public void normalMethod() {
        System.out.println("Implementation of normal method.");
    }
}

public class Test {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.defaultMethod();  // 输出: This is a default method.
        obj.normalMethod();   // 输出: Implementation of normal method.
    }
}

2. 静态方法 (Static Methods)

从Java 8开始，接口可以包含静态方法。这些方法必须有实现体，并且只能通过接口名来调用，而不能通过接口的实现类对象来调用。

例子：

interface MyInterface {
    static void staticMethod() {
        System.out.println("This is a static method inside interface.");
    }
}

public class Test {
    public static void main(String[] args) {
        MyInterface.staticMethod();  // 输出: This is a static method inside interface.
    }
}

3. 函数式接口 (Functional Interfaces)

如果一个接口只定义了一个抽象方法（不考虑从Object类继承的方法），那么它就是一个函数式接口。这种接口特别为Lambda表达式设计，以简化实例化接口的方式。

例子：

@FunctionalInterface  // 这个注解不是必须的，但建议添加来确保接口满足函数式接口的定义
interface Greeting {
    void sayHello(String name);
}

public class Test {
    public static void main(String[] args) {
        Greeting greeting = (name) -> System.out.println("Hello, " + name);
        greeting.sayHello("Alice");  // 输出: Hello, Alice
    }
}

这些新特性使得Java的接口更加强大和灵活，同时提供了一种简洁的方式来使用Lambda表达式和Stream API。

4. 同名同参数接口

如果一个类实现了两个接口，且这两个接口都提供了同名、同参数的默认方法，那么这会产生冲突。Java编译器无法确定应该使用哪个接口的默认方法。为了解决这个问题，实现类必须覆盖该冲突的方法。

让我们通过一个例子来详细说明这个问题和其解决方案：

interface InterfaceA {
    default void show() {
        System.out.println("Default method from InterfaceA");
    }
}

interface InterfaceB {
    default void show() {
        System.out.println("Default method from InterfaceB");
    }
}

class MyClass implements InterfaceA, InterfaceB {
    // 这个类必须覆盖show方法，否则会编译错误

    @Override
    public void show() {
        // 你可以选择调用某个接口的默认方法
        InterfaceA.super.show();

        // 或者你可以提供一个全新的实现
        System.out.println("My own implementation");
    }
}

public class Test {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.show();  // 输出:
                     // Default method from InterfaceA
                     // My own implementation
    }
}

在上述代码中，MyClass实现了两个接口InterfaceA和InterfaceB，它们都定义了一个名为show的默认方法。为了解决冲突，MyClass必须覆盖show方法。在覆盖的方法中，我们可以使用InterfaceName.super.methodName()的语法来调用特定接口的默认方法，或者我们可以提供一个全新的实现。

在Java 9中，接口得到了进一步的增强，引入了一个新的特性：私有方法（Private Methods）。

私有方法 (Private Methods)

在Java 9之前，接口中可以有静态方法和默认方法，但它们都是公开的。Java 9引入了接口的私有方法，允许在接口中将方法实现细节封装在私有方法中，提高代码复用性和组织性。

私有方法可以是静态的，也可以是非静态的。但是，你不能在接口的实现类中覆盖或直接调用这些私有方法。

举个例子：

public interface MyInterface {

    default void defaultMethod1() {
        commonMethod();
        System.out.println("Default method 1");
    }

    default void defaultMethod2() {
        commonMethod();
        System.out.println("Default method 2");
    }

    private void commonMethod() {
        System.out.println("Common method execution");
    }

    private static void commonStaticMethod() {
        System.out.println("Common static method execution");
    }
}

在上面的MyInterface接口中，commonMethod和commonStaticMethod是私有方法。这两个方法不能被接口的实现类调用或覆盖，但它们可以被其他接口的默认方法或静态方法调用。

这个新特性提供了一种方式，使得我们可以在接口中重用代码，而不需要使这些辅助方法成为公共API的一部分。

这是Java 9为接口引入的主要新特性，有了私有方法，接口现在可以有公有的默认方法、静态方法，以及私有的实例和静态方法，使得接口更加灵活和有组织。

冲突解决

当一个类继承的父类方法与其实现的接口的默认方法发生冲突时，如果我们仍然希望在子类中调用接口的默认方法，可以使用以下语法：

InterfaceName.super.methodName();

下面是一个例子，展示了如何在发生冲突的情况下调用接口的默认方法：

class Parent {
    void show() {
        System.out.println("Method from Parent class");
    }
}

interface InterfaceA {
    default void show() {
        System.out.println("Default method from InterfaceA");
    }
}

class Child extends Parent implements InterfaceA {
    // 显式地调用接口的默认方法
    void callInterfaceShow() {
        InterfaceA.super.show();
    }
}

public class Test {
    public static void main(String[] args) {
        Child obj = new Child();

        // 调用继承自Parent类的show方法
        obj.show();  // 输出: Method from Parent class

        // 调用InterfaceA接口的默认方法
        obj.callInterfaceShow();  // 输出: Default method from InterfaceA
    }
}

在上述代码中，Child类具有两个show方法：一个来自Parent类，另一个来自InterfaceA接口。默认情况下，由于类优先原则，当我们调用obj.show()时，会执行Parent类中的方法。为了显式地调用InterfaceA接口的默认方法，我们在Child类中定义了一个新方法callInterfaceShow，并使用InterfaceA.super.show();语法来调用接口的默认方法。

“InterfaceName.super.methodName();”这句中super表示什么？

在InterfaceName.super.methodName();这种语法中，super并不是在指代传统的类继承中的"超类"或"父类"的意义。这里，super是Java为解决接口默认方法的潜在冲突而引入的一个新语法。

具体来说，当一个类实现的多个接口有相同的默认方法，或者一个类的父类有一个方法与其实现的接口的默认方法签名相同，这时会发生冲突。为了解决这种冲突，Java提供了InterfaceName.super.methodName();这种语法，使你能够显式地指定你希望调用哪个接口的默认方法。

在这个上下文中，InterfaceName.super可以被认为是一个特殊的引用，它指向了接口的默认方法，而不是父类的方法。而super关键字则用于区分和指明我们正尝试调用的是接口的默认方法。

所以，简而言之，这里的super关键字是为了解决默认方法冲突而特别引入的语法，它指的是"接口中定义的默认实现"，而不是"父类"或"超类"。

总结

Java 8和Java 9为接口引入的新特性提供了更多的灵活性和能力，让Java开发者可以更加高效地使用接口来组织和重用代码。随着更多的特性被添加，接口的设计和使用也变得更加复杂，但这也带来了更多的机会和可能性。