当为泛型类（如 GenericClass）手动定义静态内部Builder类时，若未同步声明类型参数，Lombok生成的泛型构建方法（如 elementClazz(Class)）将因类型擦除而无法匹配非泛型Builder，导致编译错误。正确做法是使自定义Builder类本身也泛型化。

当为泛型类（如 `genericclass`）手动定义静态内部builder类时，若未同步声明类型参数，lombok生成的泛型构建方法（如 `elementclazz(class)`）将因类型擦除而无法匹配非泛型builder，导致编译错误。正确做法是使自定义builder类本身也泛型化。

在使用 Lombok 的 @Builder 注解处理泛型类时，一个常见却易被忽视的关键点是：Lombok 为泛型类生成的 Builder 类默认也是泛型的（例如 GenericClass.GenericClassBuilder），以确保构建方法（如 elementClazz(Class)）能正确保留类型参数 T。但当你手动声明一个静态内部 Builder 类（如 public static class GenericClassBuilder）时，由于该类是 static 的，它无法访问外层类的类型变量 T —— 这直接导致 Lombok 放弃生成泛型构建方法，转而尝试注入到你的非泛型 Builder 中，从而引发类型不匹配的编译错误（如 elementClazz(SomeClass.class) 被视为非法调用）。

✅ 正确解决方案：将自定义 Builder 类声明为泛型，并与外层类保持类型参数一致。

以下是修复后的完整代码示例：

import lombok.Builder;
import lombok.Data;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

@Data
@Builder
public class GenericClass<t> {
    private Class<t> elementClazz;

    @SuppressWarnings("rawtypes")
    private Class extends Collection> collectionClazz;

    private Collection<string> strings;

    /* ✅ 正确：自定义 Builder 必须是泛型的，且类型参数与外层类一致 */
    public static class GenericClassBuilder<t> {
        private Class<t> elementClazz;
        private Class extends Collection> collectionClazz;
        private Collection<string> strings;

        public GenericClassBuilder<t> elementClazz(Class<t> elementClazz) {
            this.elementClazz = elementClazz;
            return this;
        }

        public GenericClassBuilder<t> collectionClazz(Class extends Collection> collectionClazz) {
            this.collectionClazz = collectionClazz;
            return this;
        }

        public GenericClassBuilder<t> strings(Collection<string> strs) {
            if (strs == null) {
                strs = Collections.emptyList();
            }
            this.strings = strs;
            return this;
        }

        public GenericClass<t> build() {
            GenericClass<t> instance = new GenericClass();
            instance.elementClazz = this.elementClazz;
            instance.collectionClazz = this.collectionClazz;
            instance.strings = this.strings;
            return instance;
        }
    }
}

@Data
class SomeClass {
    private int number;
}

class Main {
    public static void main(String[] args) {
        // ✅ 现在可正常编译并运行
        GenericClass<someclass> result = 
            GenericClass.<someclass>builder()
                .elementClazz(SomeClass.class)
                .collectionClazz(List.class)
                .strings(List.of("a", "b"))
                .build();

        System.out.println(result.getElementClazz()); // class SomeClass
    }
}</someclass></someclass></t></t></string></t></t></t></t></string></t></t></string></t></t>

⚠️ 注意事项：

• 若你选择手动实现 Builder，必须完整覆盖所有字段的 setter 及 build() 方法，否则 Lombok 不会自动补全；
• @Builder 与自定义 Builder 类共存时，Lombok 仅注入方法到你声明的类中，不会生成额外 Builder，因此类型一致性至关重要；
• IntelliJ 等 IDE 可能因类型推导滞后而显示误报，建议以 javac 编译结果为准；
• 更简洁的替代方案：避免手动定义 Builder，改用 Lombok 自动生成 + @Singular / @Builder.Default 等增强注解，或使用 @Builder(builderMethodName = "...") 避免命名冲突。

总结：泛型类的 Builder 生效前提是“类型上下文连贯”。手动 Builder 必须泛型化，否则 T 在构建链中丢失，导致类型安全崩塌——这不是 Lombok 的 Bug，而是 Java 泛型静态语义的必然要求。