进化吧Java接口兽

我们终会上岸，⽆论去到哪⾥都是阳光灿烂鲜花开放

java在不停更新, 不同版本有不同的新特征出现, 接口在不同版本有不同的用法和区别, 总结一下java各个版本接口的用法变化和区别, 太难了

Java 8 | 不止默认还有静态

Java 8 引入了默认方法和静态方法，这些方法允许在接口中实现代码。默认方法可以在实现类中重写或调用，而静态方法只能在接口中调用。

示例：

interface MyInterface {
    default void sayHello() {
        System.out.println("Hello, world!");
    }
    static void sayBye() {
        System.out.println("Goodbye, world!");
    }
}

class MyClass implements MyInterface {
    // Default method can be overridden
    public void sayHello() {
        System.out.println("Hello, Java!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.sayHello(); // Output: Hello, Java!
        MyInterface.sayBye(); // Output: Goodbye, world!
    }
}

Java 11 | 私有接口

Java 9 引入了私有接口方法，这些方法允许在接口中定义私有方法，以便在接口内部重复使用。

示例：

interface MyInterface {
    default void sayHello() {
        saySomething("Hello, world!");
    }
    default void sayGoodbye() {
        saySomething("Goodbye, world!");
    }
    private void saySomething(String message) {
        System.out.println(message);
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {};
        obj.sayHello(); // Output: Hello, world!
        obj.sayGoodbye(); // Output: Goodbye, world!
    }
}

在上面的示例中，接口 MyInterface 定义了两个默认方法 sayHello() 和 sayGoodbye()，它们都调用了私有方法 saySomething()。在 Main 类中，我们创建了一个匿名实现类对象 obj，调用了接口中的两个默认方法。这样，我们就可以在接口中重用私有方法了。

Java 14 | record

在 Java 14 中，接口中可以定义 record 类，使得接口可以定义类似于实体类的数据结构，不再局限于只能定义抽象方法和常量。record 类是一种轻量级的数据对象，它自动提供了一些通用方法，如 equals()、hashCode()、toString() 等。

下面是一个示例：

interface Person {
    String getName();
    int getAge();
    record BasicPerson(String name, int age) implements Person {}
}

public class Main {
    public static void main(String[] args) {
        Person person = new BasicPerson("Alice", 30);
        System.out.println(person.getName() + " is " + person.getAge() + " years old.");
        System.out.println(person.toString()); // Output: BasicPerson[name=Alice, age=30]
    }
}

在上面的示例中，接口 Person 定义了两个抽象方法 getName() 和 getAge()，以及一个 record 类 BasicPerson，它实现了接口 Person。在 Main 类中，我们创建了一个 BasicPerson 对象 person，调用了它的方法和 toString() 方法。

Java 15 | Sealed与私有静态

私有静态方法

Java 15 允许在接口中添加私有静态方法，这些私有方法可以在接口中重复使用，从而提高了代码的可重用性和可维护性。

示例：

interface MyInterface {
    default void sayHello() {
        saySomething("Hello, world!");
    }
    private void saySomething(String message) {
        System.out.println(message);
    }
    default void sayBye() {
        saySomething("Goodbye, world!");
    }
    private static void sayHi() {
        System.out.println("Hi, world!");
    }
}

class MyClass implements MyInterface {
    // Default method can be overridden
    public void sayHello() {
        saySomething("Hello, Java!");
    }
    public void sayBye() {
        System.out.println("Goodbye, Java!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.sayHello(); // Output: Hello, Java!
        myObj.sayBye(); // Output: Goodbye, Java!
        MyInterface.sayHi(); // Output: Hi, world!
    }
}

Sealed

在 Java 15 中，我们可以使用 Sealed Class 特性来限制接口的实现类，使得接口更加灵活。Sealed Class 的概念来自于模式匹配，它可以将一组相关的类封装成一个密封类，然后只允许这个密封类的子类实现接口。

假设我们有一个接口 Animal，它有三个实现类：Dog、Cat 和 Bird。我们希望将这三个实现类封装成一个密封类，并限制只有这三个实现类才能实现 Animal 接口。下面是一个示例：

public sealed interface Animal permits Dog, Cat, Bird {
    String getName();
}

final class Dog implements Animal {
    private final String name;
    public Dog(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

final class Cat implements Animal {
    private final String name;
    public Cat(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

final class Bird implements Animal {
    private final String name;
    public Bird(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

在上面的示例中，我们定义了一个密封接口 Animal，并使用 permits 关键字来指定它允许的实现类。然后，我们定义了三个实现类 Dog、Cat 和 Bird，并实现了 Animal 接口。

使用 Sealed Class 特性可以使接口更加灵活，我们可以在接口中定义一个有限的、受限制的类集合，然后只允许这个集合中的类来实现接口。这样可以避免接口被不受控制的类所实现，提高了接口的可靠性和安全性。