TypeScript编译时同类型约束：如何禁止不同子类调用equals方法？

我完全理解你的需求——现在继承自通用父类（比如Mid/Entity）的业务子类（像Customer、Order），跨类调用equals会在运行时抛出TypeError，你希望把这种错误提前到编译阶段就拦截，既能避免运行时踩坑，还能减少不必要的测试用例。这确实是个很务实的优化方向，毕竟编译期错误比运行时错误友好太多了。

下面给你几个可行的实现方案，都是围绕把类型检查提前到编译阶段这个核心思路来的：

方案1：泛型父类+类型安全的equals方法 #

通过泛型限定父类的equals方法参数类型，同时废弃Object版本的equals，强制开发者使用类型匹配的方法：

public abstract class Mid<T extends Mid<T>> {
    // 类型安全的equals方法，编译期会检查参数类型
    public boolean equals(T other) {
        if (this == other) return true;
        if (other == null || getClass() != other.getClass()) return false;
        // 这里写子类通用的属性比较逻辑，或者留给子类重写
        return true;
    }

    // 覆盖Object的equals，直接抛出异常并标记为废弃，强制禁用
    @Override
    @Deprecated(since = "1.0", forRemoval = true)
    public boolean equals(Object o) {
        throw new TypeError("禁止跨类调用equals，请使用类型安全的equals(T)方法");
    }

    // 记得同步重写hashCode，保持一致性
    @Override
    public abstract int hashCode();
}

// 业务子类继承时指定自身类型
public class Customer extends Mid<Customer> {
    @Override
    public boolean equals(Customer other) {
        if (!super.equals(other)) return false;
        // 这里写Customer特有的属性比较逻辑
        return this.id.equals(other.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

public class Order extends Mid<Order> {
    @Override
    public boolean equals(Order other) {
        if (!super.equals(other)) return false;
        // Order特有的属性比较逻辑
        return this.orderNo.equals(other.orderNo);
    }

    @Override
    public int hashCode() {
        return Objects.hash(orderNo);
    }
}

这样一来，如果你尝试写new Customer().equals(new Order())，编译器会直接报错——因为Customer的equals方法只接受Customer类型的参数，完全从编译阶段就阻止了跨类调用的可能。

方案2：子类重载equals+静态代码检查 #

如果不想修改父类的结构，可以在每个业务子类中重载一个参数为自身类型的equals方法，同时配合静态代码分析工具拦截Object版本equals的跨类调用：

public class Customer extends Mid {
    // 类型安全的重载方法，编译期检查参数类型
    public boolean equals(Customer other) {
        if (this == other) return true;
        if (other == null) return false;
        return this.id.equals(other.id);
    }

    // 覆盖Object的equals，仅允许同类型调用
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Customer)) {
            throw new TypeError("只能与Customer类型实例比较");
        }
        return equals((Customer) o);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

然后用Checkstyle、SonarQube这类工具自定义规则：检测如果代码中调用equals时传入的参数不是当前类的实例，就触发编译错误。这种方式兼顾了兼容性，又能在编译阶段拦截问题。

方案3：密封类+模式匹配（Java 17+） #

如果你的项目使用Java 17及以上，可以把父类设为密封类，只允许指定的业务子类继承，然后用模式匹配在equals中做严格的类型检查，配合静态工具也能实现编译期拦截：

public sealed class Mid permits Customer, Order {}

public final class Customer extends Mid {
    @Override
    public boolean equals(Object o) {
        return o instanceof Customer customer && this.id.equals(customer.id);
    }
}

public final class Order extends Mid {
    @Override
    public boolean equals(Object o) {
        return o instanceof Order order && this.orderNo.equals(order.orderNo);
    }
}

虽然这种方式的类型检查还是在运行时，但结合IDE的静态提示（比如当你传入非对应类型时，IDE会高亮警告），再配合静态代码分析规则，也能有效减少跨类调用的情况。

总结 #

这几种方案都能帮你实现编译阶段禁止跨类equals调用的目标，其中方案1的泛型方式最直接，从语法层面就阻止了错误；方案2更适合已有项目的改造；方案3则是利用Java新特性的优雅实现。不管选哪种，都能帮你避免运行时的TypeError，还能省去不少针对跨类比较的测试用例。

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