如何定义仅接受实现类类型的抽象方法并规避跨类不当实现？

你提的这个问题是泛型自限定（CRTP）用法里常见的小漏洞——原有的T extends Parent约束只要求T是Parent的子类，但没法强制T必须是当前实现类本身，所以才会出现Child1 extends Parent<Child>这种不符合预期的实现。下面给你两种可行的解决思路：

方案1：运行时检查（最实用的约束方式） #

我们可以在抽象类的构造器中加入类型校验，确保泛型参数T就是当前子类的实际类型。这样即使有人写出不当实现，在实例化时会直接抛出异常，从根源上阻止错误的使用。

修改后的抽象类：

public abstract class Parent<T extends Parent<T>> {
    private final Class<T> actualType;

    // 构造器要求子类传入自身的Class对象
    protected Parent(Class<T> actualType) {
        this.actualType = actualType;
        // 检查当前实例的类是否与泛型参数的类完全一致
        if (!this.getClass().equals(actualType)) {
            throw new IllegalArgumentException("泛型参数T必须是当前实现类自身");
        }
    }

    public abstract void foo(T t);
}

合规的子类实现：

public class Child extends Parent<Child> {
    public Child() {
        // 传入自身的Class对象，顺利通过检查
        super(Child.class);
    }

    @Override
    public void foo(Child child) {
        // 业务逻辑实现
    }
}

而你提到的不当实现Child1在实例化时会直接触发报错：

public class Child1 extends Parent<Child> {
    public Child1() {
        // 传入Child.class，但当前实例是Child1，运行时抛出IllegalArgumentException
        super(Child.class);
    }

    @Override
    public void foo(Child child) { /* ... */ }
}

方案2：编译时约束（近似实现） #

Java的类型系统目前没法完全在编译时强制T必须是子类自身，但可以通过设计手段提高不当实现的成本，让这种写法变得非常不自然：

// 定义标记接口，要求实现类绑定自身类型
interface SelfBound<T> {}

public abstract class Parent<T extends Parent<T> & SelfBound<T>> {
    public abstract void foo(T t);
}

// 合规实现：正确绑定自身类型
public class Child extends Parent<Child> implements SelfBound<Child> {
    @Override
    public void foo(Child child) { /* ... */ }
}

// 不当实现：语法上可行，但需要额外实现SelfBound<Child>，违背设计意图
public class Child1 extends Parent<Child> implements SelfBound<Child> {
    @Override
    public void foo(Child child) { /* ... */ }
}

这种方式只能增加不当实现的门槛，无法完全阻止，所以更推荐方案1的运行时检查——既能有效约束，实现成本也很低。

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