003｜接口与抽象类：设计取舍、默认方法以及面向接口编程

public interface PaymentService {
    PaymentResult pay(PaymentRequest request);
    PaymentStatus queryStatus(String transactionId);
}

// 接口表达的是"能力"
public interface Flyable {
    void fly();
}

// 两个完全不相关的类可以共享同一个能力契约
public class Bird implements Flyable { ... }
public class Airplane implements Flyable { ... }

public abstract class BaseRepository<T, ID> {
    // 具体方法：提供默认实现
    public Optional<T> findById(ID id) {
        return getEntityManager().find(getEntityClass(), id);
    }

    // 抽象方法：强制子类实现
    protected abstract EntityManager getEntityManager();
    protected abstract Class<T> getEntityClass();
}

public abstract class AbstractCsvParser<T> {
    private final String filePath;          // 共享状态
    private final Charset charset;          // 共享状态

    protected AbstractCsvParser(String filePath, Charset charset) {
        this.filePath = filePath;
        this.charset = charset;
    }

    public final List<T> parse() {          // 模板方法

        List<String[ ]> rows = readCsv();

        return rows.stream()
            .map(this::mapRow)             // 抽象方法——子类填充
            .collect(Collectors.toList());
    }


    private List<String[ ]> readCsv() { ... } // 内部实现细节


    protected abstract T mapRow(String[ ] row); // 子类只需关心映射逻辑

}

public class OrderService implements
    Transactional,      // 事务能力
    Auditable,          // 审计能力
    Cacheable,          // 缓存能力
    MetricsCollectable  // 指标采集能力
{
    // 通过组合多个接口，灵活装配对象能力
}

public abstract class ConnectionPool {
    // 对外暴露的接口
    public Connection getConnection() { ... }
    public void releaseConnection(Connection conn) { ... }

    // 子类可以重写的钩子方法，但不对外暴露
    protected Connection createConnection() { ... }
    protected boolean validateConnection(Connection conn) { ... }
}

// is-a：用抽象类建模
public abstract class Animal {
    protected String name;
    public abstract void breathe();
}

// can-do：用接口建模
public interface Runnable { void run(); }
public interface Swimmable { void swim(); }
public interface Trainable { void perform(String command); }

public class Dog extends Animal implements Runnable, Swimmable, Trainable {
    // Dog is an Animal (is-a)
    // Dog can Run, Swim, be Trained (can-do)
}

// v1.0
public interface ConfigSource {
    String get(String key);
}

// v2.0：向后兼容地新增能力
public interface ConfigSource {
    String get(String key);

    // 新增：提供默认实现，不影响 v1.0 的实现类
    default String getOrDefault(String key, String defaultValue) {
        String value = get(key);
        return value != null ? value : defaultValue;
    }
}

public interface Collection<E> extends Iterable<E> {
    // Java 8 新增：Stream 支持
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

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

// 旧模式：接口 + 伴生类
public interface Comparator<T> {
    int compare(T o1, T o2);
}

public class Comparators {  // 伴生工具类
    public static <T> Comparator<T> naturalOrder() { ... }
}

// Java 8 新模式：静态方法直接放在接口中
public interface Comparator<T> {
    int compare(T o1, T o2);

    static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (o1, o2) -> o1.compareTo(o2);
    }

    static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return (o1, o2) -> {
            if (o1 == null) return -1;
            if (o2 == null) return 1;
            return comparator.compare(o1, o2);
        };
    }
}

public interface EventProcessor {
    default void processEvent(Event event) {
        validateNotNull(event);
        doProcess(event);
        logProcess(event);
    }

    default void processBatch(List<Event> events) {
        events.forEach(this::validateNotNull);
        events.forEach(this::doProcess);
        events.forEach(this::logProcess);
    }

    // Java 9：私有方法，隐藏内部实现
    private void validateNotNull(Event event) {
        if (event == null) throw new IllegalArgumentException("Event cannot be null");
    }
    private void logProcess(Event event) {
        logger.debug("Processed event: {}", event.getId());
    }
}

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

interface B extends A {
    default void hello() { System.out.println("B"); }  // 子接口优先
}

class Parent {
    public void hello() { System.out.println("Parent"); }  // 类优先
}

class Child extends Parent implements B {
    // 不需要重写 —— Parent.hello() 胜出（类优先原则）
}

// 冲突场景
interface X { default void greet() { System.out.println("X"); } }
interface Y { default void greet() { System.out.println("Y"); } }

class MyClass implements X, Y {
    // 必须显式解决冲突！
    @Override
    public void greet() {
        X.super.greet();  // 显式选择 X 的实现
    }
}

// ❌ 反例：应该用接口
public abstract class Logger {
    public abstract void log(String message);
    public abstract void error(String message);
}
// 这里不需要共享状态，应该定义为接口

// ✅ 正例：应该用抽象类
public abstract class BaseService {
    protected final DataSource dataSource;      // 需要共享状态
    protected final MetricsRegistry metrics;    // 需要共享状态

    protected BaseService(DataSource ds, MetricsRegistry mr) {
        this.dataSource = ds;
        this.metrics = mr;
    }

    // 模板方法：定义执行骨架
    public final Result execute(Request req) {
        metrics.increment("request.count");
        Timer.Context timer = metrics.startTimer("request.latency");
        try {
            validate(req);
            return doExecute(req);
        } finally {
            timer.stop();
        }
    }

    protected abstract void validate(Request req);
    protected abstract Result doExecute(Request req);
}

// 示例：观察字节码差异
public class MethodDispatchDemo {
    public void testVirtual(ArrayList<String> list) {
        list.size();  // → invokevirtual （ArrayList 的方法）
    }

    public void testInterface(List<String> list) {
        list.size();  // → invokeinterface （List 接口的方法）
    }
}

// 用 javap -c 查看：
// invokevirtual #2  // Method java/util/ArrayList.size:()I
// invokeinterface #3, 1  // InterfaceMethod java/util/List.size:()I

// ❌ 紧耦合：依赖具体实现
public class OrderService {
    private MySQLOrderRepository repository = new MySQLOrderRepository();  // 直接依赖

    public Order findById(Long id) {
        return repository.findById(id);
    }
}

// ✅ 面向接口编程：依赖抽象
public class OrderService {
    private final OrderRepository repository;  // 依赖接口

    public OrderService(OrderRepository repository) {  // 依赖注入
        this.repository = repository;
    }

    public Order findById(Long id) {
        return repository.findById(id);
    }
}

// 现在可以轻松替换实现
new OrderService(new MySQLOrderRepository(dataSource));
new OrderService(new RedisCachedOrderRepository(redis, mysql));
new OrderService(new MockOrderRepository());  // 便于单元测试

// ❌ 违反 ISP：胖接口
public interface Worker {
    void work();
    void eat();
    void sleep();
}

// ✅ 遵循 ISP：接口拆分
public interface Workable { void work(); }
public interface Eatable { void eat(); }
public interface Sleepable { void sleep(); }

// 人类实现所有接口
public class Human implements Workable, Eatable, Sleepable { ... }

// 机器人不需要 eat 和 sleep
public class Robot implements Workable { ... }

public interface Serializable { }  // 标记可序列化
public interface Cloneable { }     // 标记可克隆

// 自定义标记接口
public interface Auditable { }     // 标记需要审计
public interface CacheEvictable { } // 标记缓存可驱逐

// ❌ 反模式：用接口定义常量
public interface Constants {
    int MAX_RETRY = 3;
    String DEFAULT_CHARSET = "UTF-8";
}

// ✅ 正确做法：使用 final 类或枚举
public final class AppConstants {
    private AppConstants() {}
    public static final int MAX_RETRY = 3;
    public static final String DEFAULT_CHARSET = "UTF-8";
}

@FunctionalInterface
public interface EventHandler<T> {
    void handle(T event);

    // 可以包含多个 default/static 方法
    default EventHandler<T> andThen(EventHandler<T> after) {
        return event -> {
            handle(event);
            after.handle(event);
        };
    }
}

public abstract class BaseEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    // 子类自动继承序列化能力
}

public interface Foo {
    // 编译错误！default 方法不能重写 Object 的方法
    // default boolean equals(Object o) { ... }
}

// ❌ 反模式：default 方法中包含重要业务逻辑
public interface OrderValidator {
    boolean validate(Order order);

    // default 方法承担了过多逻辑
    default void validateAndThrow(Order order) {
        if (!validate(order)) {
            throw new OrderValidationException(...);
        }
        // 复杂的状态变更...
    }
}

interface Parser {
    static Parser create() { return new DefaultParser(); }
}

class MyParser implements Parser {
    void foo() {
        // MyParser.create();  // ❌ 编译错误！static 方法不被继承
        Parser.create();       // ✅ 必须通过接口名调用
    }
}

public sealed interface PaymentMethod
    permits CreditCard, BankTransfer, DigitalWallet { }

public record CreditCard(String number, String cvv) implements PaymentMethod { }
public record BankTransfer(String iban) implements PaymentMethod { }
public record DigitalWallet(String walletId) implements PaymentMethod { }
// public class Cash implements PaymentMethod { }  // ❌ 编译错误！

public String describe(PaymentMethod method) {
    return switch (method) {
        case CreditCard c -> "信用卡支付: " + c.number();
        case BankTransfer b -> "银行转账: " + b.iban();
        case DigitalWallet w -> "数字钱包: " + w.walletId();
        // 不需要 default 分支——编译器验证了穷尽性
    };
}

// Producer Extends, Consumer Super
public interface Repository<T> {
    void save(T entity);                          // Consumer → 可以用 ? super T
    Optional<T> findById(ID id);                  // Producer → 可以用 ? extends T

    // 灵活方法
    default void saveAll(Collection<? extends T> entities) {  // Producer
        entities.forEach(this::save);
    }
}

public interface DataProcessor<T> {
    default T process(T input) {
        T validated = validate(input);    // 调用自身的 validate
        T enriched = enrich(validated);    // 调用自身的 enrich
        return transform(enriched);        // 调用自身的 transform
    }
    default T validate(T input) { return input; }
    default T enrich(T input) { return input; }
    T transform(T input);
}

public class UserProcessor implements DataProcessor<User> {
    @Override
    public User transform(User input) { ... }
    // 使用了 process()，但没有重写 validate() 和 enrich()
    // 这合理吗？如果不合理，问题在哪？
}