不修改基类Root实现多态：替代类型判断与强制转换的方案

现有类层次结构如下：

public abstract class Root {
    ...
}

public class A extends Root {
    ...
}

public class B extends Root {
    ...
}

public class C extends Root {
    ...
}

希望对静态类型为Root的对象应用func函数，让函数行为依赖对象的具体动态类型。原本可通过多态实现：在Root中定义抽象函数，各子类分别实现，但Root代码无法修改。目前想到的方案是在A、B、C中分别实现func，再通过以下方式调用：

public static void applyFuncOnRootObject(Root object) {
    if (object instanceof A) {
        ((A) object).func();
    } else if (object instanceof B) {
        ...
    }
    ...
}

请问是否有更优方案，可避免繁琐的类型判断与强制转换？

1. 访问者模式（Visitor Pattern） #

这是处理“无法修改父类但需按子类类型执行不同逻辑”场景的经典方案。

首先定义访问者接口，包含对应每个子类的访问方法：

public interface RootVisitor {
    void visit(A a);
    void visit(B b);
    void visit(C c);
}

在每个子类中添加accept方法（子类代码可修改）：

public class A extends Root {
    public void accept(RootVisitor visitor) {
        visitor.visit(this);
    }
    // 自定义func方法
    public void func() { ... }
}

// B、C类同理添加accept方法

实现访问者类，将原func调用逻辑放入对应visit方法：

public class FuncVisitor implements RootVisitor {
    @Override
    public void visit(A a) {
        a.func();
    }

    @Override
    public void visit(B b) {
        b.func();
    }

    @Override
    public void visit(C c) {
        c.func();
    }
}

最终调用时无需类型判断：

public static void applyFuncOnRootObject(Root object) {
    object.accept(new FuncVisitor());
}

后续新增子类，只需扩展访问者接口和实现类，无需修改原有逻辑。

2. 基于类型映射的策略模式 #

若不想引入访问者的接口和类，可借助Map存储类型与对应操作的映射，结合Java 8+函数式接口简化代码：

private static final Map<Class<? extends Root>, Consumer<? super Root>> FUNC_HANDLERS = new HashMap<>();

static {
    FUNC_HANDLERS.put(A.class, obj -> ((A) obj).func());
    FUNC_HANDLERS.put(B.class, obj -> ((B) obj).func());
    FUNC_HANDLERS.put(C.class, obj -> ((C) obj).func());
}

public static void applyFuncOnRootObject(Root object) {
    Consumer<? super Root> handler = FUNC_HANDLERS.get(object.getClass());
    if (handler != null) {
        handler.accept(object);
    } else {
        // 处理未匹配类型的情况，如抛出异常或执行默认逻辑
        throw new IllegalArgumentException("Unsupported Root type: " + object.getClass());
    }
}

这种方式将分散的if-else集中到静态初始化块，新增子类只需在Map中添加对应条目即可。若存在子类的子类（如A1 extends A），需额外处理父类类型的匹配逻辑。

3. Java 16+ 模式匹配 #

使用Java 16及以上版本时，可利用instanceof的模式匹配特性，简化强制转换代码（虽仍有分支，但可读性大幅提升）：

public static void applyFuncOnRootObject(Root object) {
    if (object instanceof A a) {
        a.func();
    } else if (object instanceof B b) {
        b.func();
    } else if (object instanceof C c) {
        c.func();
    } else {
        // 默认处理逻辑
    }
}

此方案无需显式强制转换，适合子类数量不多的场景。

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