Java中抽象方法契约校验：断言局限与接口契约强制方案

一、抽象类场景：替换断言为强制运行时校验 #

你之前用断言校验_initCells返回值的思路有问题——断言本身是调试阶段的自检工具，默认处于禁用状态，完全不适合用来做生产环境的契约强制。

正确的做法是把断言逻辑换成普通的条件判断，抛出明确的异常：

public final void initCells() {
    Cell[] cells = _initCells();
    // 检查重复单元格
    Set<Cell> cellSet = new HashSet<>();
    for (Cell cell : cells) {
        if (!cellSet.add(cell)) {
            throw new IllegalArgumentException("存在重复单元格: " + cell);
        }
        // 检查单元格是否越界（假设Cell类有isOutOfBounds()方法）
        if (cell.isOutOfBounds()) {
            throw new IllegalArgumentException("单元格越界: " + cell);
        }
    }
    // 后续初始化逻辑...
}

因为initCells是final修饰的，子类无法重写这个方法，不管子类怎么实现_initCells，返回值都会被严格校验，一旦违反契约就会抛出异常，完全绕不开约束。

你的临时方案用System.exit终止程序过于粗暴，会直接中断整个进程，调用方连补救的机会都没有。抛出异常才符合Java的异常处理规范：调用方可以捕获异常排查问题，或者让异常向上传播，明确告知契约违反的原因。

二、接口场景：用「接口+抽象适配器类」或工厂模式强制契约 #

接口本身无法包含带实现的方法（Java 8+的默认方法可以被子类重写，所以也靠不住），要强制契约可以用以下两种方案：

方案1：接口+抽象适配器类（推荐） #

先定义核心业务接口：

public interface Cells {
    void initCells();
}

再写一个抽象适配器类，实现接口并加入契约校验逻辑，同时把需要子类自定义的部分抽成抽象方法：

public abstract class AbstractCells implements Cells {
    @Override
    public final void initCells() {
        Cell[] cells = _initCells();
        // 复用之前的校验逻辑，抛出异常
        Set<Cell> cellSet = new HashSet<>();
        for (Cell cell : cells) {
            if (!cellSet.add(cell)) {
                throw new IllegalArgumentException("存在重复单元格: " + cell);
            }
            if (cell.isOutOfBounds()) {
                throw new IllegalArgumentException("单元格越界: " + cell);
            }
        }
        // 后续初始化逻辑...
    }

    protected abstract Cell[] _initCells();
}

要求其他开发者必须继承AbstractCells，而非直接实现Cells接口。因为initCells是final方法，子类无法跳过校验，完美实现契约强制。

方案2：工厂模式+动态代理（适合无法限制子类继承的场景） #

如果必须允许开发者直接实现接口，可以用动态代理包装实例，在调用initCells时自动校验契约：

public class CellsFactory {
    public static Cells createCells(Cells delegate) {
        return (Cells) Proxy.newProxyInstance(
            Cells.class.getClassLoader(),
            new Class[]{Cells.class},
            (proxy, method, args) -> {
                if ("initCells".equals(method.getName())) {
                    // 先执行子类的初始化逻辑
                    method.invoke(delegate, args);
                    // 假设接口有getCells()方法获取单元格数组，这里做校验
                    Cell[] cells = delegate.getCells();
                    Set<Cell> cellSet = new HashSet<>();
                    for (Cell cell : cells) {
                        if (!cellSet.add(cell)) {
                            throw new IllegalArgumentException("存在重复单元格: " + cell);
                        }
                        if (cell.isOutOfBounds()) {
                            throw new IllegalArgumentException("单元格越界: " + cell);
                        }
                    }
                    return null;
                } else {
                    return method.invoke(delegate, args);
                }
            }
        );
    }
}

但这种方案要求开发者必须通过工厂获取实例，不能直接new，否则校验会失效，约束性不如方案1可靠。

总结 #

• 抽象类场景：用抛出异常的条件判断替代断言，结合final方法确保子类无法绕过校验。
• 接口场景：优先采用「接口+抽象适配器类」的组合，通过final方法强制契约；若必须开放接口实现，可考虑工厂+动态代理，但约束性稍弱。
• 绝对不要用System.exit终止程序，抛出明确的异常才是正确的错误处理方式。

内容的提问来源于stack exchange，提问作者Gor Madatyan