web-dev-qa-db-ja.com

Javaでネストされた列挙型を使用する

次のようなことができるように、ネストされた列挙型を含むデータ構造を念頭に置いています。

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

そして、メソッド宣言があった場合：

someMethod(Drink type)
someOtherMethod(DrinkTypeInterface type)

その後、私は言うことができます（適切に）：

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

これは私が思いついたものです：

public enum Drink {

    COFFEE("Coffee");

    private String groupName;

    private Drink(String groupName) {
        this.groupName = groupName;
    }

    public enum Coffee implements DrinkTypeInterface {

        COLUMBIAN("Columbian Blend"),
        ETHIOPIAN("Ethiopian Blend");

        private String label;

        private Coffee(String label) {
            this.label = label;
        }

        public String getLabel() {
            return this.label;
        }
    }

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

そしてインターフェース：

public interface DrinkTypeInterface {

    public String getLabel();
}

この種のことを行う最善の方法がJavaであるか、個々のDrink.values（）を処理するために大量のifステートメントを記述する必要がある場合は、頭を包み込んでいるだけだと思います。助けがありますか？

javaenumsnested-class
29
Chris
Drink.COFFEE.getGroupName();
Drink.COFFEE.COLUMBIAN.getLabel();

まず、与えられたサンプルコードは、「デメテルの法則」にいくらか違反しています-COLUMBIANインスタンスフィールドはラベルの取得にのみ使用されるためです。また、その構造では、COLUMBIAN has toはCOFFEE列挙型のインスタンスになりますが、ここでは本当にそれが目的だとは思いません。

someMethod(Drink type)
someOtherMethod(DrinkTypeInterface type)

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

私があなたのサンプルから収集しているのは、実際の飲み物が何であるかの「グループタイプ」を含む列挙を持ち、それぞれが特定の種類の飲み物に対して個別の値を持っているということです。あなたの例はコーヒーを与えますが、お茶も同様に機能するはずです。

問題は、列挙をどのように配置したかです。前にも言ったように、COLUMBIANをCOFFEE列挙型のインスタンスにする必要がありますが、これは実際にこれを構成する最良の方法ではありません。

問題は、飲み物、次にコーヒー/紅茶、そしてそれぞれの種類があることです。ただし、考えてみると、HerbalTea IS A Teaですが、ドリンクでもあります-単にTEAのインスタンスとして属しているわけではありません。

しかし、飲み物type自体を列挙型にすると、必要なものが得られ、構造がより明確になります。インターフェイスと委任の力により、次のプログラム例のように、飲み物の種類と飲み物の列挙の両方を同じ方法で処理できます。

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

さて、何らかの理由ですべての飲み物を単一の列挙型にしたくない場合、私はあなたが何を目指しているのか理解できませんでした。その場合、列挙にまたがる機能がある場合は、コーヒーと紅茶（およびその他）の列挙を個別に作成し、両方（またはそれ以上）の列挙にインターフェイスを適用します。しかし、あなたはこのようにグループ化しようとしていたと思います。

36
MetroidFan2002

here のように、さまざまなタイプのEnumSetを収集するために Drink を使用することを検討してください。

補遺：具体的な例として、以下のコードは表示される出力を生成します。

コーヒー：コロンビアブレンド
コーヒー：エチオピアブレンド

コード：

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());
    }
}
12
trashgod

私は最近これがいくぶん満足にできるかどうか興味がありました。これは私が最終的に解決したものであり、そのAPIはまた、質問者が最初に望んでいた列挙型のツリー構造に近いと思います：

public interface Drink {

    String groupName();
    String label();

    enum Coffee implements Drink {

        COLUMBIAN("Columbian Blend"),
        ETHIOPIAN("Ethiopian Blend");

        private final String label;

        Coffee(String label) {
            this.label = label;
        }

        @Override
        public String groupName() {
            return "Coffee";
        }

        @Override
        public String label() {
            return label;
        }
    }

    enum Tea implements Drink {

        MINT("Mint"),
        HERBAL("Herbal"),
        EARL_GREY("Earl Grey");

        private final String label;

        Tea(String label) {
            this.label = label;
        }

        @Override
        public String groupName() {
            return "Tea";
        }

        @Override
        public String label() {
            return label;
        }
    }
}

public static void main(String[] args) {
    Drink choice = Drink.Tea.EARL_GREY;

    System.out.println(choice.groupName());  // Tea
    System.out.println(choice.label());  // Earl Grey
}
1
skoskav

次のようなことができます：

enum dogs {
    boxer, collie;
}
enum cats {
    siamese, tom
}
enum Animal {
    cat(cats.tom), dog(dogs.boxer);
    Animal(Enum e) {
        this.e = e;
    }
    Object[] subValues() {
        return e.getDeclaringClass().getEnumConstants();
    }
    final Enum e;
}
public class Main {
    public static void main(String[] args) {
        for (Animal animal : Animal.values()) {
            System.out.print(animal);
            for (Object o : animal.subValues())
                System.out.print(" " + o);
            System.out.println();
        }
    }
}
0
Ray Tayek