如何设计代码结构避免? extends _的不兼容类型捕获问题

你遇到的编译失败本质是泛型擦除导致的类型信息丢失：存入List<O<? extends P>>的O实例会丢失具体的泛型参数类型，存入List<P>的载荷实例也会向上转型为基类P，编译器无法证明遍历取出的第i个O支持的载荷类型刚好和第i个P的类型匹配，因此会阻断编译。

方案1：访问者模式（适合载荷类型固定、操作逻辑复杂多变的场景） #

访问者模式可以实现双分派，不用将业务逻辑写到载荷类中，完全满足你将复杂逻辑放在O类中的需求，编译期就能检查类型覆盖完整性：

改造步骤： #

1. 定义载荷访问者接口

public interface PVisitor {
    void visit(P1 p1);
    void visit(P2 p2);
}

2. 改造P基类和子类，增加接受访问者的方法

public static abstract class P {
    public abstract void accept(PVisitor visitor);
}

public static class P1 extends P {
    public String a = "a";
    @Override
    public void accept(PVisitor visitor) {
        visitor.visit(this);
    }
}

public static class P2 extends P {
    public Integer b = 1;
    @Override
    public void accept(PVisitor visitor) {
        visitor.visit(this);
    }
}

3. 让O的子类实现PVisitor接口，绑定处理逻辑

public static class O1 extends O<P1> implements PVisitor {
    @Override
    public void execute(P1 payload) {
        // 你的复杂业务逻辑都写在这里
        System.out.println(payload.a);
    }

    @Override
    public void visit(P1 p1) {
        execute(p1);
    }

    @Override
    public void visit(P2 p2) {
        // 不匹配类型的自定义处理逻辑，比如抛异常、跳过等
        throw new IllegalArgumentException("O1不支持P2类型载荷");
    }
}

public static class O2 extends O<P2> implements PVisitor {
    @Override
    public void execute(P2 payload) {
        System.out.println(payload.b);
    }

    @Override
    public void visit(P1 p1) {
        throw new IllegalArgumentException("O2不支持P1类型载荷");
    }

    @Override
    public void visit(P2 p2) {
        execute(p2);
    }
}

4. 改造调用逻辑

public static void main(String[] args) {
    List<PVisitor> os = List.of(new O1(), new O2());
    List<P> ps = List.of(new P1(), new P2());

    for (int i = 0; i < 2; i++) {
        ps.get(i).accept(os.get(i));
    }
}

方案2：配对封装（适合O与P严格一一对应的场景） #

如果你的业务中O和P的对应关系是固定的，不需要动态组合，直接将配对的O和P封装成一个对象，从根源上避免类型不匹配的问题，编译期100%保证类型安全：

改造步骤： #

1. 定义配对封装类

static class OpPair<T extends P> {
    private final O<T> operator;
    private final T payload;

    public OpPair(O<T> operator, T payload) {
        this.operator = operator;
        this.payload = payload;
    }

    public void execute() {
        operator.execute(payload);
    }
}

2. 改造调用逻辑

public static void main(String[] args) {
    List<OpPair<?>> pairs = List.of(
        new OpPair<>(new O1(), new P1()),
        new OpPair<>(new O2(), new P2())
    );
    pairs.forEach(OpPair::execute);
}

你尝试的p.getClassType().cast(p)无法通过编译，是因为getClassType()返回的类型是Class<? extends P>，cast之后得到的对象类型还是? extends P，编译器仍然无法证明这个类型和当前O的泛型参数匹配，因此不会放行。

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