Java 17中持有父类对象时，如何避免类型转换访问子类属性？

现有父类和两个子类结构如下：

public class Parent {
    private Type type;
}

public class Child1 extends Parent {
    private String someField;
    public Child1() {
        super(Type.One);
    }
}

public class Child2 extends Parent {
    private String someOtherField;
    public Child2() {
        super(Type.Two);
    }
}

业务中持有Parent对象，需要根据Type枚举值访问子类属性，当前采用switch+类型转换的实现方式：

switch(parent.type){
    case Type.One:
        Child1 child = (Child1) parent;
        // 业务逻辑
        break;
    case Type.Two:
        Child2 child = (Child2) parent;
        // 业务逻辑
        break;
}

限制条件：使用Java 17，无法使用预览版switch模式匹配；不能修改上述任何类。除了switch/访问者模式结合类型转换，有没有更优更清晰的实现方式？

方案1：基于类型映射的策略模式 #

把每个Type对应的子类处理逻辑封装成独立的处理器，用Map做映射，解耦类型判断和业务逻辑，代码更易维护。

具体实现 #

1. 定义一个函数式接口统一处理逻辑：

@FunctionalInterface
interface ChildHandler<T extends Parent> {
    void handle(T child);
}

2. 初始化处理器映射，把每个Type对应的类型转换和业务逻辑绑定：

private static final Map<Type, ChildHandler<? extends Parent>> HANDLER_MAP = Map.of(
    Type.One, (Child1 child) -> {
        // 直接写Child1的业务逻辑，比如访问someField
        System.out.println(child.someField);
    },
    Type.Two, (Child2 child) -> {
        // 处理Child2的业务逻辑，访问someOtherField
        System.out.println(child.someOtherField);
    }
);

3. 调用时只需根据Type获取处理器执行：

public void processParent(Parent parent) {
    ChildHandler<? extends Parent> handler = HANDLER_MAP.get(parent.type);
    if (handler == null) {
        throw new IllegalArgumentException("Unsupported type: " + parent.type);
    }
    
    // 这里的switch仅做类型转换，业务逻辑都在处理器里
    switch (parent.type) {
        case One:
            ((ChildHandler<Child1>) handler).handle((Child1) parent);
            break;
        case Two:
            ((ChildHandler<Child2>) handler).handle((Child2) parent);
            break;
    }
}

如果不想写这个小switch，也可以用反射简化（性能损耗可忽略，适合大部分场景）：

public void processParent(Parent parent) {
    ChildHandler<? extends Parent> handler = HANDLER_MAP.get(parent.type);
    if (handler == null) {
        throw new IllegalArgumentException("Unsupported type: " + parent.type);
    }
    
    try {
        Method handleMethod = handler.getClass().getMethod("handle", Object.class);
        handleMethod.invoke(handler, parent);
    } catch (ReflectiveOperationException e) {
        throw new RuntimeException("Failed to process parent", e);
    }
}

优势 #

• 新增子类时，只需要在HANDLER_MAP里加一条新的处理器，不用修改调用逻辑
• 每个子类的业务逻辑集中在一起，代码结构更清晰
• 避免了重复的类型转换代码

方案2：封装类型转换工具类 #

把类型转换和校验逻辑抽成工具类，让业务代码更干净，减少重复代码。

具体实现 #

public class ParentConverter {
    public static Child1 toChild1(Parent parent) {
        if (parent.type != Type.One) {
            throw new IllegalArgumentException("Parent instance is not Child1");
        }
        return (Child1) parent;
    }

    public static Child2 toChild2(Parent parent) {
        if (parent.type != Type.Two) {
            throw new IllegalArgumentException("Parent instance is not Child2");
        }
        return (Child2) parent;
    }
}

业务代码里这样用：

switch (parent.type) {
    case One:
        Child1 child1 = ParentConverter.toChild1(parent);
        // 业务逻辑
        break;
    case Two:
        Child2 child2 = ParentConverter.toChild2(parent);
        // 业务逻辑
        break;
}

优势 #

• 把类型校验和转换逻辑集中管理，避免业务代码里重复写判断
• 出错时能抛出更明确的异常，方便排查问题

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