在 Java 中使用嵌套枚举类型

Drink.COFFEE.getGroupName();
Drink.COFFEE.COLUMBIAN.getLabel();

首先，您给出的示例代码在某种程度上违反了“demeter定律” - 因为COLUMBIAN实例字段仅用于检索标签。此外，有了这个结构，哥伦比亚必须成为COFFEE枚举的一个实例，但我不认为这是你真正想要的。

someMethod(Drink type)
someOtherMethod(DrinkTypeInterface type)

someMethod(Drink.COFFEE)
someOtherMethod(Drink.COFFEE.COLUMBIAN)

我从你的样本中收集到的是，你想要一个包含实际饮料的“组类型”的枚举，然后每个都有特定类型饮料的单独值。你的例子给出了咖啡，但茶也应该同样有效。

问题在于如何放置枚举。正如我之前所说，你必须让COLUMITION成为COFFEE枚举的实例，但这并不是构建它的最佳方式。

问题是你有饮料，然后是咖啡/茶，然后是他们的个人类型。但是，如果你仔细想想，虽然HerbTea是一种茶，但它也是一种饮料 - 所以它不属于茶的一个实例。

但是，如果你把饮料类型本身作为一个枚举，你就会得到你想要的，结构就会变得更加清晰。由于接口和授权的力量，饮料类型和饮料枚举都可以以相同的方式处理，如以下示例程序所示：

public final class DrinkEnumExample {

    public interface DrinkTypeInterface {

        String getDisplayableType();
    }

    public static enum DrinkType implements DrinkTypeInterface {

        COFFEE("Coffee"), TEA("Tea");
        private final String type;

        private DrinkType(final String type) {
            this.type = type;
        }

        public String getDisplayableType() {
            return type;
        }
    }

    public static enum Drink implements DrinkTypeInterface {

        COLUMBIAN("Columbian Blend", DrinkType.COFFEE),
        ETHIOPIAN("Ethiopian Blend", DrinkType.COFFEE),
        MINT_TEA("Mint", DrinkType.TEA),
        HERBAL_TEA("Herbal", DrinkType.TEA),
        EARL_GREY("Earl Grey", DrinkType.TEA);
        private final String label;
        private final DrinkType type;

        private Drink(String label, DrinkType type) {
            this.label = label;
            this.type = type;
        }

        public String getDisplayableType() {
            return type.getDisplayableType();
        }

        public String getLabel() {
            return label;
        }
    }

    public DrinkEnumExample() {
        super();
    }

    public static void main(String[] args) {
        System.out.println("All drink types");
        for (DrinkType type : DrinkType.values()) {
            displayType(type);
            System.out.println();
        }
        System.out.println("All drinks");
        for (Drink drink : Drink.values()) {
            displayDrink(drink);
            System.out.println();
        }
    }

    private static void displayDrink(Drink drink) {
        displayType(drink);
        System.out.print(" - ");
        System.out.print(drink.getLabel());
    }

    private static void displayType(DrinkTypeInterface displayable) {
        System.out.print(displayable.getDisplayableType());
    }
}

该程序的输出如下：

All drink types 
Coffee 
Tea 
All drinks 
Coffee - Columbian Blend 
Coffee - Ethiopian Blend
Tea - Mint 
Tea - Herbal 
Tea - Earl Grey

那么，如果由于某种原因，你不想把所有的饮料都放在一个整体中，那么我不明白你要做什么。在这种情况下，如果您确实具有跨枚举的功能，请进行单独的 Coffee 和 Tea（以及任何内容）枚举，并将接口应用于两个（或多个）枚举。但是，我认为你试图像这样将它们分组。

请考虑使用 EnumSet 来收集不同类型的 ，如此处所建议的那样。Drink

附录：作为一个具体示例，下面的代码生成所示的输出。

Coffee: Columbian Blend
Coffee: Ethiopian Blend

法典：

public static enum DrinkType {

    COFFEE("Coffee"), TEA("Tea");
    private final String displayName;

    private DrinkType(final String displayName) {
        this.displayName = displayName;
    }

    public String getDisplayName() {
        return displayName;
    }
}

public enum Drink {

    COLUMBIAN(DrinkType.COFFEE, "Columbian Blend"),
    ETHIOPIAN(DrinkType.COFFEE, "Ethiopian Blend"),
    MINT_TEA(DrinkType.TEA, "Mint"),
    HERBAL_TEA(DrinkType.TEA, "Herbal"),
    EARL_GREY(DrinkType.TEA, "Earl Grey");
    public static Set<Drink> coffees = EnumSet.of(COLUMBIAN, ETHIOPIAN);
    public static Set<Drink> teas = EnumSet.range(MINT_TEA, EARL_GREY);
    private String groupName;
    private String drinkName;

    private Drink(DrinkType type, String drinkName) {
        this.groupName = type.getDisplayName();
        this.drinkName = drinkName;
    }

    public String getGroupName() {
        return this.groupName;
    }

    public String getDrinkName() {
        return drinkName;
    }
}

public static void main(String... args) {
    for (Drink d : Drink.coffees) {
        System.out.println(d.getGroupName() + ": " + d.getDrinkName());
    }
}