我可以在 Java 枚举上使用构建器模式吗

mySheet1, mySheet2等是枚举常量，遵循第 8.9.1 节中定义的 JLS 语法

枚举常量： 注解opt 标识符 参数opt 类体opt

因此，您可以在枚举常量后面加上参数列表（要传递给构造函数的参数），但不能在声明枚举常量时调用该方法。您最多可以为其添加一个类主体。

除此之外，您使用构建器模式来构建枚举实例是有问题的，因为通常，当您拥有大量实例（字段值的组合）时，会使用构建器模式，而使用用于少数实例的枚举概念。

您可以使用实例块（通常错误地称为“双大括号初始值设定项”）来自定义具有任意代码的构造：

public enum workBookSheet {

    mySheet1("Name1", "mainSheet1.xls", true, 1) {{
        addSubSheet("pathToSubSheet1.xls");
    }},
    mySheet2("Name2", "mainSheet2.xls", true, 2) {{
        // you can use the fluent interface:
        addHeaderSheet("pathToHeaders.xls").addSubSheet("pathtoSubSheet2.xls");
        // but I would prefer coding separate statements:
        addHeaderSheet("pathToHeaders.xls");
        addSubSheet("pathtoSubSheet2.xls");
    }};

    // rest of your class the same...
}

使用这种语法可以绕过构建器/流畅模式施加的限制，但仍然具有构建器/流畅模式的简洁性、便利性和灵活性。enum

虽然它并不严格符合构建器模式，但简短的回答是肯定的。算是吧。

缺少的部分是无法调用来实例化枚举常量，因为 build（） 不能使用 .但是，您可以获得构建器模式的很多好处。让我们面对现实吧，你不能使用静态工厂方法，枚举常量的内联子类化很奇怪。.build()new

下面是使用 Country 枚举的示例。

package app;

import org.apache.commons.lang.StringUtils;
import javax.annotation.Nullable;
import java.util.EnumSet;
import java.util.Set;
import static app.Language.*;
import static com.google.common.base.Preconditions.*;

enum Language {
    ITALIAN,
    ENGLISH,
    MALTESE
}

public enum Country {

    ITALY(new Builder(1, "Italy").addLanguage(ITALIAN)),
    MALTA(new Builder(2, "Malta").addLanguages(MALTESE, ENGLISH, ITALIAN).setPopulation(450_000));

    final private int id;
    final private String name;
    final private Integer population;
    final private Set<Language> languages;

    private static class Builder {

        private int id;
        private String name;
        private Integer population;
        private Set<Language> languages = EnumSet.noneOf(Language.class);

        public Builder(int id, String name) {
            checkArgument(!StringUtils.isBlank(name));

            this.id = id;
            this.name = name;
        }

        public Builder setPopulation(int population) {
            checkArgument(population > 0);

            this.population = population;
            return this;
        }

        public Builder addLanguage(Language language) {
            checkNotNull(language);

            this.languages.add(language);
            return this;
        }

        public Builder addLanguages(Language... language) {
            checkNotNull(language);

            this.languages.addAll(languages);
            return this;
        }
    }

    private Country(Builder builder) {

        this.id = builder.id;
        this.name = builder.name;
        this.population = builder.population;
        this.languages = builder.languages;

        checkState(!this.languages.isEmpty());
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Nullable
    public Integer getPopulation() {
        return population;
    }

    public Set<Language> getLanguages() {
        return languages;
    }
}

如果您有构建常量的常用方法，您甚至可以将静态工厂方法放在构建器中。

所以它不完全是布洛赫的建造者，但它非常接近。