如何为Java静态工具类实现无需实例化的Builder风格功能？

当然可以实现！你想要的这种无需用户手动实例化任何类的Builder风格配置，核心思路是通过静态内部Builder类维护一个隐藏的单例实例（或按需创建实例），对外暴露静态配置方法完成链式调用，完全屏蔽实例化细节。下面结合你的工具类示例给出完整实现方案：

完整代码实现 #

import java.util.*;

class MyClass {
    // 原有的静态成员变量
    private static List<String> userList = new ArrayList<>();
    private static Map<Integer, String> userMap = new HashMap<>();
    private static LinkedList<Double> userDoubleList = new LinkedList<>();
    private static Map<Integer, SomeClass> someClassMap = new HashMap<>();

    // 静态内部Builder类
    public static class Builder {
        // 临时存储配置的变量
        private String tempUserString;
        private Integer tempUserNumber;
        private Double tempUserDouble;
        private Integer tempSomeClassKey;
        private SomeClass tempSomeClassValue;

        // 私有构造方法，禁止外部手动实例化
        private Builder() {}

        // 静态单例实例，对外完全隐藏
        private static final Builder INSTANCE = new Builder();

        // 静态配置方法，作为链式调用的入口，返回单例实例
        public static Builder option1(String userString) {
            INSTANCE.tempUserString = userString;
            return INSTANCE;
        }

        // 链式配置方法，继续返回单例实例
        public Builder option2(Integer userNumber, String userString) {
            INSTANCE.tempUserNumber = userNumber;
            INSTANCE.tempUserString = userString;
            return INSTANCE;
        }

        public Builder option3(Double userDouble) {
            INSTANCE.tempUserDouble = userDouble;
            return INSTANCE;
        }

        public Builder option4(Integer userInteger, SomeClass userClass) {
            INSTANCE.tempSomeClassKey = userInteger;
            INSTANCE.tempSomeClassValue = userClass;
            return INSTANCE;
        }

        // build方法：将临时配置同步到外部类静态成员，然后重置临时变量
        public static void build() {
            // 应用配置（非空判断避免覆盖默认值）
            if (INSTANCE.tempUserString != null) {
                MyClass.userList.add(INSTANCE.tempUserString);
            }
            if (INSTANCE.tempUserNumber != null && INSTANCE.tempUserString != null) {
                MyClass.userMap.put(INSTANCE.tempUserNumber, INSTANCE.tempUserString);
            }
            if (INSTANCE.tempUserDouble != null) {
                MyClass.userDoubleList.addLast(INSTANCE.tempUserDouble);
            }
            if (INSTANCE.tempSomeClassKey != null && INSTANCE.tempSomeClassValue != null) {
                MyClass.someClassMap.put(INSTANCE.tempSomeClassKey, INSTANCE.tempSomeClassValue);
            }

            // 重置临时变量，避免后续配置被残留值干扰
            resetTempValues();
        }

        private static void resetTempValues() {
            INSTANCE.tempUserString = null;
            INSTANCE.tempUserNumber = null;
            INSTANCE.tempUserDouble = null;
            INSTANCE.tempSomeClassKey = null;
            INSTANCE.tempSomeClassValue = null;
        }
    }

    // 原有的工具方法（可保留，也可完全用Builder替代）
    public static void method1(String userString) {
        userList.add(userString);
    }

    public static void method2(Integer userNumber, String userString) {
        userMap.put(userNumber, userString);
    }

    public static void method3(Double userDouble) {
        userDoubleList.addLast(userDouble);
    }

    public static void method4(Integer userInteger, SomeClass userClass) {
        someClassMap.put(userInteger, userClass);
    }

    // 示例依赖类
    static class SomeClass {}
}

核心设计要点 #

• 隐藏实例化细节：Builder的构造方法设为私有，用户无法手动new，内部通过静态单例INSTANCE处理所有配置逻辑。
• 链式调用支持：静态配置方法返回单例实例，后续的配置方法继续返回该实例，实现流畅的链式调用。
• 配置隔离：每次build后自动重置临时变量，避免不同配置操作之间的干扰。
• 灵活组合：用户可以自由组合不同的optionX方法，一次性完成多个静态成员的配置，替代零散的工具方法调用。

使用方式 #

用户完全不需要实例化任何类，直接通过静态入口调用：

// 单个配置项
MyClass.Builder.option1("My String").build();

// 多配置项组合
MyClass.Builder.option2(1, "User 1")
               .option3(25.4)
               .option4(2, new MyClass.SomeClass())
               .build();

注意事项 #

• 线程安全：单例模式下多线程同时配置会导致临时变量被覆盖。如果需要线程安全，有两种方案：
  1. 给所有optionX和build方法添加synchronized同步锁。
  2. 改为静态配置方法创建新的Builder实例（内部实例化但用户感知不到），每个链式调用独立：

     public static Builder option1(String userString) {
         Builder builder = new Builder();
         builder.tempUserString = userString;
         return builder;
     }
     

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