#Java 8 接口默认方法

// JDK 8 之前：接口不能有实现
interface A {
    void method();
}

// 如果要给所有实现类提供一个通用实现：
// 方案一：在每个实现类中重复代码（糟糕）
// 方案二：抽象类替代接口（限制了多继承）

// JDK 8 之后：默认方法
interface A {
    default void method() {
        // 通用实现
    }
}

// JDK 8 之前：
interface Iterator<E> {
    E next();
    boolean hasNext();
}

// JDK 8 添加了 forEach 方法：
// 如果不提供默认实现，所有旧实现类都必须修改
// → 引入 default 方法，所有旧实现类自动获得 forEach 的默认行为

interface Iterator<E> {
    default void forEach(Consumer<? super E> action) {
        while (hasNext()) {
            action.accept(next());
        }
    }
}

// 新增方法时，无需修改所有实现类
interface DatabaseDriver {
    // 新增方法，提供默认实现
    default Connection connect() {
        throw new UnsupportedOperationException();
    }
}

// Iterable 的 forEach 方法（JDK 8 新增）
interface Iterable<T> {
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
}

// List 的 replaceAll 方法
interface List<E> {
    default void replaceAll(UnaryOperator<E> operator) {
        // ...
    }
}

interface A {
    default void method() { System.out.println("A"); }
}

interface B {
    default void method() { System.out.println("B"); }
}

class MyClass implements A, B {
    // ❌ 如果不重写，编译错误
    // 编译器不知道该选 A 的还是 B 的

    @Override
    public void method() {
        // ✅ 必须显式选择
        A.super.method(); // 调用 A 的实现
        // B.super.method(); // 或调用 B 的实现
    }
}

abstract class AbstractClass {
    void method() { System.out.println("AbstractClass"); }
}

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

// 类优先规则：子类继承父类的实现，忽略接口的默认方法
class MyClass extends AbstractClass implements InterfaceA {
    // 不需要重写 method()
    // 直接使用 AbstractClass 的 method()
}

new MyClass().method(); // 输出：AbstractClass

interface A {
    default void method() { System.out.println("A"); }
}

interface B {
    default void method() { System.out.println("B"); }
}

// ❌ 两个同级接口都有默认方法，且没有父类
// class MyClass implements A, B { } // 编译错误

// ✅ 必须显式重写
class MyClass implements A, B {
    @Override
    public void method() {
        // 选择一个或两个都调用
        A.super.method();
        B.super.method();
    }
}

interface A {
    default void method() { System.out.println("A"); }
}

interface B extends A { } // B 继承 A 的 method

interface C extends A { } // C 也继承 A 的 method

// D 同时实现 B 和 C
// B 和 C 都继承了 A 的 method，没有冲突
// D 仍然可以使用 A 的默认 method，无需重写
class D implements B, C {
    // ✅ 可以不重写
    // A.method() 是唯一的默认实现
}

new D().method(); // 输出：A

interface Path {
    // 静态方法：通过接口名直接调用
    static Path of(String path) {
        return new PathImpl(path);
    }

    static Path of(String first, String... more) {
        // ...
    }
}

// 使用
Path p = Path.of("/usr/local");

interface Collection<E> {
    // JDK 8 新增
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

// 如果需要：
// - 多实现能力 → 接口
// - 单继承 + 共享状态 → 抽象类
// - 纯粹的行为契约 → 接口
// - 需要构造器 → 抽象类
// - 需要非 public 方法 → 抽象类