#抽象类与接口区别

// 抽象类：代表"是什么"
abstract class Animal {
    abstract void speak(); // 动物都能叫，但叫法不同

    void breathe() {       // 所有动物呼吸方式相同
        System.out.println("Breathing");
    }
}

class Dog extends Animal { // Dog is an Animal
    @Override
    void speak() { System.out.println("Woof"); }
}

// 接口：代表"能做什么"
interface Swimmer {
    void swim();
}

interface Flyer {
    void fly();
}

class Duck extends Animal implements Swimmer, Flyer {
    // Duck is an Animal, can swim, can fly
    @Override
    void speak() { System.out.println("Quack"); }

    @Override
    public void swim() { System.out.println("Swimming"); }

    @Override
    public void fly() { System.out.println("Flying"); }
}

// 选择抽象类的场景：
// 1. 需要共享状态（字段）
// 2. 需要继承通用行为（具体方法）
// 3. 需要非 public 访问修饰符
// 4. 需要构造器
abstract class BaseController {
    protected Response handleError(Exception e) { // protected，具体实现
        // ...
    }
}

// 选择接口的场景：
// 1. 需要多实现（能力强耦合）
// 2. 定义行为契约，不需要实现
// 3. 多个不相关的类需要相同行为
interface Serializable {
    byte[] serialize();
}

interface Comparable<T> {
    int compareTo(T other);
}

interface Calculator {
    int calculate(int a, int b);

    // JDK 8+ 默认方法：有实现
    default int add(int a, int b) {
        return a + b;
    }

    default String getName() {
        return "Calculator";
    }
}

// 使用：
class SimpleCalculator implements Calculator {
    @Override
    public int calculate(int a, int b) {
        return a - b; // 只实现 calculate
    }
    // add() 和 getName() 继承自默认实现
}

Calculator calc = new SimpleCalculator();
calc.add(1, 2); // 3，调用默认方法

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

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

// ❌ 编译错误：两个默认方法冲突
// class C implements A, B { }

// ✅ 必须显式重写
class C implements A, B {
    @Override
    public void method() {
        // 选择一个
        A.super.method(); // 调用 A 的默认实现
        // 或 B.super.method();
        // 或自定义实现
    }
}

interface Path {
    // JDK 8+ 静态方法
    static Path of(String str) {
        return new PathImpl(str);
    }

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

// 使用：
Path p = Path.of("/usr/local"); // 通过接口名调用

interface Service {
    default void start() {
        // 调用私有辅助方法
        validate();
        initialize();
    }

    default void stop() {
        // 复用相同的辅助方法
        cleanup();
        validate();
    }

    // JDK 9+ 私有方法：代码复用，减少重复
    private void validate() { /* ... */ }
    private void initialize() { /* ... */ }
    private void cleanup() { /* ... */ }
}

abstract class BaseService {
    // 模板方法：固定算法骨架
    public final void process() {
        step1();
        step2();
        step3();
    }

    abstract void step1(); // 子类必须实现
    abstract void step2();

    // 通用步骤有默认实现
    protected void step3() {
        System.out.println("Default step3");
    }
}

// JDK 的经典例子：Collections.sort
public interface Comparator<T> {
    int compare(T o1, T o2);
    // JDK 8+ 还有其他默认/静态方法
}

// String 类实现了 Comparable 接口
public final class String implements Comparable<String> {
    @Override
    public int compareTo(String o) { /* ... */ }
}

// 唯一本质区别：是否支持多继承
// 抽象类：只能单继承
// 接口：可以多实现

// 其他所有区别都是因为"多继承"的语义延伸：
// - 字段：接口只能是常量（避免多继承状态冲突）
// - 构造器：抽象类可以有（子类构造器调用 super()）
// - 私有方法：接口的 private 方法只是 JDK 9 为了代码复用引入的语法糖

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

    // JDK 8+ default 方法：提供便利实现
    default Comparator<T> reversed() { return Collections.reverseOrder(this); }
    default Comparator<T> thenComparing(Comparator<? super T> other) { /* ... */ }
    default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) { /* ... */ }
    // 还有更多...
}