抽象类与接口对比

// 抽象类定义算法骨架
public abstract class DataExporter {
    // 模板方法：final 防止篡改
    public final void export() {
        openConnection();
        fetchData();
        formatData();
        writeOutput();
        closeConnection();
    }

    protected abstract void fetchData();     // 抽象：子类实现
    protected abstract void formatData();    // 抽象：子类实现

    private void openConnection() { /* 通用实现 */ }
    private void writeOutput()   { /* 通用实现 */ }
    private void closeConnection(){ /* 通用实现 */ }
}

// 接口定义策略
public interface PaymentStrategy {
    void pay(double amount);
}

// 策略一
public class CreditCardStrategy implements PaymentStrategy {
    public void pay(double amount) { /* 信用卡支付 */ }
}

// 策略二
public class AlipayStrategy implements PaymentStrategy {
    public void pay(double amount) { /* 支付宝支付 */ }
}

// 上下文类——面向接口编程
public class PaymentContext {
    private PaymentStrategy strategy;

    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;  // 运行时切换策略
    }

    public void executePayment(double amount) {
        strategy.pay(amount);
    }
}

// JDK 中的经典案例：MouseAdapter
// MouseListener 是接口（5个方法）
public interface MouseListener {
    void mouseClicked(MouseEvent e);
    void mousePressed(MouseEvent e);
    void mouseReleased(MouseEvent e);
    void mouseEntered(MouseEvent e);
    void mouseExited(MouseEvent e);
}

// MouseAdapter 是抽象类——为所有方法提供空实现
public abstract class MouseAdapter implements MouseListener {
    public void mouseClicked(MouseEvent e) { }
    public void mousePressed(MouseEvent e) { }
    public void mouseReleased(MouseEvent e) { }
    public void mouseEntered(MouseEvent e) { }
    public void mouseExited(MouseEvent e) { }
}

// 用户只需继承 MouseAdapter，重写关心的那一个方法
new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("点击了！");
    }
};

// JDK 7 时代：接口只能有抽象方法和常量
public interface Payable {
    double MIN_AMOUNT = 0.01;        // 常量
    void pay(double amount);          // 抽象方法
    String getPaymentMethod();       // 抽象方法
}

// JDK 8：接口可以有 default 方法和 static 方法
public interface Payable {
    // ---- 抽象方法（子类必须实现） ----
    void pay(double amount);
    String getPaymentMethod();

    // ---- default 方法（提供默认实现，子类可选重写） ----
    default void printReceipt(double amount) {
        System.out.println("支付金额：" + amount);
        System.out.println("支付方式：" + getPaymentMethod());
    }

    default void validateAmount(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须大于0");
        }
    }

    // ---- static 方法（工具/工厂方法） ----
    static Payable of(String type, String account) {
        switch (type) {
            case "BANK": return new BankPayment("默认银行", account);
            case "ALIPAY": return new AlipayPayment(account);
            default: throw new IllegalArgumentException("未知类型: " + type);
        }
    }

    static boolean isValid(double amount) {
        return amount > 0 && amount < 1_000_000;
    }
}

// ❌ 错误：所有员工都用接口，丢失了共享状态的优势
public interface Employee {
    String getName();  // 每个实现类都要自己写 getName
    String getId();    // 每个实现类都要自己写 getId
    double calculateSalary();
}

// 问题：name 和 id 的存储、getter 实现完全重复
public class FullTimeEmployee implements Employee {
    private String name;  // 重复
    private String id;    // 重复
    // + getter 重复实现
}

public class Intern implements Employee {
    private String name;  // 重复
    private String id;    // 重复
    // + getter 重复实现
}

// ❌ 错误：Invoice 不是 Employee，却继承了 Employee 只是为了复用字段
public class Invoice extends Employee {
    // Invoice（发票）不是一个 Employee（员工），is-a 不成立！
    private String invoiceNo;
}

// ✅ 正确
public class Invoice implements Payable {
    private String invoiceNo;
    // 实现 Payable 的方法
}

// ❌ 误区：因为 JDK 8 接口有 default 方法，就把所有抽象类改成接口
public interface Employee {
    String name;  // ❌ 这实际是 public static final 常量，不是实例变量！

    default String getName() {
        return name;  // ❌ name 是常量，所有"实例"共享同一个值！
    }
}