能否无需显式转换推断Builder返回类型以直接调用子类方法？

问题背景 #

在《Effective Java》第2条中，Joshua Bloch以披萨为例介绍了构建器模式。我对示例做了简化，希望通过枚举值获取对应的构建器而非直接实例化：

public static <T extends Person.Builder<T>> T newBuilder(Template template) {
    return (T) switch (template) {
        case FRIEND -> new Friend.Builder();
        case STRANGER -> null;
    };
}

现在遇到的问题是：必须将返回的构建器转换为对应子类类型才能调用子类特有的方法，但基类方法可以直接调用：

// 隐式转换为Friend.Builder后可正常调用子类方法
Friend.Builder friendBuilder = newBuilder(Template.FRIEND);
friendBuilder.setNickname("friend");

// 无需转换可直接调用基类方法setDescription
newBuilder(Template.FRIEND).setDescription("very friendly");

// 不转换的话无法调用子类方法setNickname（编译报错）
newBuilder(Template.FRIEND).setNickname("friend");

请问有没有办法让编译器自动推断返回类型，或者在switch中做处理，让我无需显式转换就能直接调用子类的方法？

以下是涉及的三个完整类代码：

PersonService（主类） #

public class PersonService {
    public static void main(String[] args) {
        // 隐式转换后正常工作
        Friend.Builder friendBuilder = newBuilder(Template.FRIEND);
        friendBuilder.setNickname("friend");

        // 无需转换可调用基类方法
        newBuilder(Template.FRIEND).setDescription("very friendly");

        // 无转换时无法调用子类方法（编译报错）
        // newBuilder(Template.FRIEND).setNickname("friend");
    }

    public static <T extends Person.Builder<T>> T newBuilder(Template template) {
        return (T) switch (template) {
            case FRIEND -> new Friend.Builder();
            case STRANGER -> null;
        };
    }
}

Person基类 #

public abstract class Person {
    private final String description;

    protected Person(Builder<?> builder) {
        this.description = builder.description;
    }

    static abstract class Builder<T extends Builder<T>> {
        private String description;

        public T setDescription(String description) {
            this.description = description;
            return self();
        }

        public abstract Person build();
        
        protected abstract T self();
    }

    public enum Template { STRANGER, FRIEND }
}

Friend子类 #

public class Friend extends Person {
    public Friend(Builder builder) {
        super(builder);
    }

    public static class Builder extends Person.Builder<Builder> {
        private String nickname;

        public void setNickname(String nickname) {
            this.nickname = nickname;
        }

        @Override
        public Friend build() {
            return new Friend(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }
}

解决方案 #

要让编译器自动识别具体Builder子类类型，你可以从以下几种方案中选择：

方案1：显式指定泛型类型调用 #

调用newBuilder时直接指定返回的具体Builder类型，让编译器明确识别子类方法：

// 显式指定泛型类型为Friend.Builder
PersonService.<Friend.Builder>newBuilder(Template.FRIEND).setNickname("friend");

这种方式不需要修改现有方法结构，仅需在调用时添加类型声明，简单直接。

方案2：重构方法，让模板与Builder类型强绑定 #

方式A：给枚举添加泛型关联字段

修改Person.Template枚举，让每个枚举值绑定对应的Builder类，消除强制类型转换：

public abstract class Person {
    // ... 原有代码省略 ...

    public enum Template<T extends Builder<T>> {
        STRANGER(null),
        FRIEND(Friend.Builder.class);

        private final Class<T> builderClass;

        Template(Class<T> builderClass) {
            this.builderClass = builderClass;
        }

        public T createBuilder() throws InstantiationException, IllegalAccessException {
            return builderClass.newInstance();
        }
    }
}

然后更新newBuilder方法：

public static <T extends Person.Builder<T>> T newBuilder(Person.Template<T> template) {
    try {
        return template.createBuilder();
    } catch (Exception e) {
        throw new RuntimeException("Failed to create builder", e);
    }
}

调用时编译器会自动推断类型：

newBuilder(Person.Template.FRIEND).setNickname("friend"); // 正常编译

这种方式类型安全性更高，但需要处理反射实例化的异常，适合需要动态扩展模板的场景。

方式B：重载newBuilder方法

为每个模板类型提供独立的重载方法，直接返回具体Builder类型：

public static Friend.Builder newFriendBuilder() {
    return new Friend.Builder();
}

public static Stranger.Builder newStrangerBuilder() {
    return new Stranger.Builder();
}

调用时直接使用对应方法：

newFriendBuilder().setNickname("friend");

这种方式代码最直观，完全没有类型转换问题，可读性最高，适合模板数量不多的场景。

方案3：添加类型标记参数辅助推断 #

在newBuilder方法中额外传入Builder类型的Class对象，帮助编译器明确类型：

public static <T extends Person.Builder<T>> T newBuilder(Template template, Class<T> type) {
    return (T) switch (template) {
        case FRIEND -> new Friend.Builder();
        case STRANGER -> null;
    };
}

调用时传入类型：

newBuilder(Template.FRIEND, Friend.Builder.class).setNickname("friend");

这种方式需要额外传参，略显繁琐，仅作为备选方案。

总结 #

• 若不想修改现有方法结构，优先选方案1；
• 若追求代码清晰和类型安全，优先选方案2B；
• 若需要动态扩展模板类型，可考虑方案2A。

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