接口进化：默认方法、静态方法与私有方法

// Java 7 及之前：接口只能有抽象方法和常量
public interface MyCollection<E> {
    // 常量（隐式 public static final）
    int MAX_SIZE = 1000;

    // 抽象方法（隐式 public abstract）
    void add(E element);
    boolean remove(E element);
    int size();
}

// 问题：如果 Collection 接口要新增一个 forEach 方法？
// 答：所有实现类（ArrayList、HashMap、LinkedList...）全部编译失败！

public interface Greeting {
    // 抽象方法 —— 实现类必须实现
    String getName();

    // 默认方法 —— 提供默认实现，实现类可选覆写
    default String greet() {
        return "Hello, " + getName() + "!";
    }

    // 另一个默认方法，可以调用其他方法
    default String greetFormal() {
        return "Dear " + getName() + ", welcome.";
    }
}

// 实现类 A：继承默认实现
public class EnglishGreeting implements Greeting {
    public String getName() { return "Alice"; }
    // greet() 和 greetFormal() 自动继承默认实现
}

// 实现类 B：覆写默认方法
public class ChineseGreeting implements Greeting {
    public String getName() { return "张三"; }

    @Override
    public String greet() {
        return "你好，" + getName() + "！";
    }
}

public interface Collection<E> {
    // ... 原有的抽象方法 ...

    // Java 8 新增 —— 全部是 default 方法！
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    default void forEach(Consumer<? super E> action) {
        for (E e : this) {
            action.accept(e);
        }
    }

    default boolean removeIf(Predicate<? super E> filter) {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (filter.test(it.next())) { it.remove(); return true; }
        }
        return false;
    }
}

/* ─── 规则 1：类优先于接口 ─── */
interface Greetable {
    default String hello() { return "Hi from interface"; }
}
class Base {
    public String hello() { return "Hi from class"; }
}
class Child extends Base implements Greetable {}
// new Child().hello() → "Hi from class"  (类优先)

/* ─── 规则 2：子接口优先于父接口 ─── */
interface Animal {
    default String speak() { return "..."; }
}
interface Dog extends Animal {
    default String speak() { return "Woof!"; }
}
class Puppy implements Dog {}
// new Puppy().speak() → "Woof!"  (Dog 比 Animal 更具体)

/* ─── 规则 3：平级冲突 → 必须显式选择 ─── */
interface A { default void log() { System.out.println("A"); } }
interface B { default void log() { System.out.println("B"); } }

class MyService implements A, B {
    // 编译器报错！必须覆写并显式选择
    @Override
    public void log() {
        A.super.log();  // 显式选择 A 的实现
    }
}

public interface Validator<T> {
    boolean isValid(T value);

    // 静态方法：通过接口名直接调用
    static <T> Validator<T> always() {
        return value -> true;
    }

    static <T> Validator<T> notNull() {
        return Objects::nonNull;
    }
}

// 使用：不需要单独的 ValidatorUtils 类
Validator<String> v1 = Validator.always();
Validator<String> v2 = Validator.notNull();

public interface Comparator<T> {
    int compare(T o1, T o2);

    // 静态工厂方法 —— 以前在 Collections 工具类中
    static <T, U extends Comparable<? super U>>
    Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor) {
        return (a, b) -> keyExtractor.apply(a).compareTo(keyExtractor.apply(b));
    }

    static <T> Comparator<T> naturalOrder() { ... }
    static <T> Comparator<T> reverseOrder() { ... }
}

// 使用：直接通过接口名调用
users.sort(Comparator.comparing(User::getAge));

public interface Logger {

    // 公共逻辑：格式化和输出（私有方法，不暴露给实现类）
    private String format(String level, String msg) {
        return String.format("[%s] %s - %s", level, LocalDateTime.now(), msg);
    }

    // 私有 static 方法
    private static void writeToConsole(String formatted) {
        System.out.println(formatted);
    }

    // default 方法复用私有方法
    default void info(String msg) {
        writeToConsole(format("INFO", msg));
    }

    default void warn(String msg) {
        writeToConsole(format("WARN", msg));
    }

    default void error(String msg) {
        writeToConsole(format("ERROR", msg));
    }

    // 唯一的抽象方法
    void write(String formatted);
}

// Q1: 接口可以有方法体吗？
// 答：Java 8 起支持 default 和 static 方法，Java 9 起支持 private 方法

// Q2: 一个类实现多个接口，default 方法冲突了怎么办？
// 答：三条规则——类优先 > 子接口优先 > 平级冲突必须显式 InterfaceA.super.method()

// Q3: default 方法和抽象类有什么区别？
// 答：接口支持多实现但不能有状态（实例字段），抽象类有状态但只能单继承

// Q4: @FunctionalInterface 注解和 default 方法的关系？
// 答：default 方法不影响函数式接口判定，@FunctionalInterface 只看抽象方法数量
//     例如 Predicate 有 test() 抽象方法 + and()/or()/negate() default 方法

// Q5: Java 9 的接口私有方法解决了什么问题？
// 答：解决多个 default 方法之间的代码重复问题，
//     允许抽取公共逻辑而不暴露给实现类