Quelles sont les énumérations et pourquoi sont-ils utiles?

Pourquoi utiliser un langage de programmation? La raison pour laquelle nous avons des langues est pour

1. programmeurs efficaces et correctement express algorithmes dans une forme que les ordinateurs peuvent utiliser.
2. mainteneurs pour comprendre les algorithmes d'autres ont écrit et correctement faire des changements.

la lisibilité sans écrire beaucoup de texte standard. Si vous êtes prêt à écrire boilerplate, alors vous pouvez "simuler" enums:

public class Color {
    private Color() {} // Prevent others from making colors.
    public static final Color RED = new Color();
    public static final Color AMBER = new Color();
    public static final Color GREEN = new Color();
}

Maintenant vous pouvez écrire:

Color trafficLightColor = Color.RED;

Le standard ci-dessus a le même effet que

public enum Color { RED, AMBER, GREEN };

les deux fournissent le même niveau d'aide de vérification du compilateur. Boilerplate est encore plus tapant. Mais économiser beaucoup de Dactylographie rend le programmeur plus efficace (voir 1), Il est donc une caractéristique utile.

cela vaut la peine pour au moins une raison de plus, aussi:

les instructions Switch

une chose que le static final simulation enum ci-dessus ne pas vous donner est agréable switch cas. Pour les types enum, le commutateur Java utilise le type de sa variable pour déduire la portée des cas enum, donc pour les enum Color au-dessus de vous avez simplement besoin de dire:

Color color = ... ;
switch (color) {
    case RED:
        ...
        break;
}

notez que ce n'est pas Color.RED dans les cases. Si vous n'utilisez pas enum, la seule façon d'utiliser les quantités nommées avec switch est quelque chose comme:

public Class Color {
    public static final int RED = 0;
    public static final int AMBER = 1;
    public static final int GREEN = 2;
}

mais maintenant une variable pour tenir une couleur doit avoir le type int . La vérification du compilateur de nice de l'enum et de la simulation static final est terminée. Pas heureux.

Un compromis est d'utiliser un scalaires membre dans la simulation:

public class Color {
    public static final int RED_TAG = 1;
    public static final int AMBER_TAG = 2;
    public static final int GREEN_TAG = 3;

    public final int tag;

    private Color(int tag) { this.tag = tag; } 
    public static final Color RED = new Color(RED_TAG);
    public static final Color AMBER = new Color(AMBER_TAG);
    public static final Color GREEN = new Color(GREEN_TAG);
}

Maintenant:

Color color = ... ;
switch (color.tag) {
    case Color.RED_TAG:
        ...
        break;
}

mais notez, encore plus de boilerplate!

utilisant un enum comme un singleton

Dans le code ci-dessus, vous pouvez voir pourquoi un enum fournit un moyen d'implémenter un singleton. Au lieu d'écrire:

public class SingletonClass {
    public static final void INSTANCE = new SingletonClass();
    private SingletonClass() {}

    // all the methods and instance data for the class here
}

et y accéder avec

SingletonClass.INSTANCE

on peut juste dire

public enum SingletonClass {
    INSTANCE;

    // all the methods and instance data for the class here
}

qui nous donne la même chose. Nous pouvons nous en tirer avec cela parce que Java enums sont mis en œuvre en tant que classes complètes avec seulement un peu de sucre syntaxique saupoudré sur le dessus. C'est encore moins compliqué, mais ce n'est pas évident à moins que l'idiome vous soit familier. Je n'aime pas non plus le fait que vous obteniez les diverses fonctions d'enum même si elles n'ont pas beaucoup de sens pour le singleton: ord et values , etc. (Il y a en fait une simulation plus délicate où Color extends Integer fonctionnera avec switch, mais c'est tellement délicat que cela montre encore plus clairement pourquoi enum est une meilleure idée.)

Filet de sécurité

la sécurité du filetage n'est un problème potentiel que lorsque des singletons sont créés sans verrouillage.

public class SingletonClass {
    private static SingletonClass INSTANCE;
    private SingletonClass() {}
    public SingletonClass getInstance() {
        if (INSTANCE == null) INSTANCE = new SingletonClass();
        return INSTANCE;
    }

    // all the methods and instance data for the class here
}

si plusieurs threads appellent getInstance simultanément alors que INSTANCE est toujours nul, n'importe quel nombre d'instances peut être créé. Ce qui est mauvais. La seule solution est d'ajouter synchronized accès pour protéger la variable INSTANCE .

cependant, le code static final ci-dessus n'a pas ce problème. Il crée l'instance avidement au temps de charge de classe. Chargement de classe est synchronisé.

Le enum singleton est effectivement paresseux parce qu'il n'est pas initialisé avant la première utilisation. Java l'initialisation est également synchronisée, de sorte que plusieurs threads ne peuvent pas initialiser plus d'une instance de INSTANCE . Vous obtenez un singleton paresseusement initialisé avec très peu de code. Le seul négatif est la syntaxe plutôt obscure. Vous devez connaître l'idiome ou bien comprendre comment le chargement de classe et l'initialisation fonctionnent pour savoir ce qui se passe.

outre les cas d'utilisation déjà mentionnés, je trouve souvent des énums utiles pour mettre en œuvre le modèle de stratégie, en suivant quelques lignes directrices de base OOP:

1. ayant le code où se trouvent les données (c'est-à-dire à l'intérieur de l'enum lui-même -- ou souvent à l'intérieur des constantes de l'enum, qui peuvent outrepasser les méthodes).
2. implémenter une interface (ou plus) afin de ne pas lier le code client à l'enum (qui ne devrait fournir qu'un ensemble de application.)

l'exemple Le plus simple serait un ensemble de Comparator implémentations:

enum StringComparator implements Comparator<String> {
    NATURAL {
        @Override
        public int compare(String s1, String s2) {
            return s1.compareTo(s2);
        }
    },
    REVERSE {
        @Override
        public int compare(String s1, String s2) {
            return NATURAL.compare(s2, s1);
        }
    },
    LENGTH {
        @Override
        public int compare(String s1, String s2) {
            return new Integer(s1.length()).compareTo(s2.length());
        }
    };
}

ce "pattern" peut être utilisé dans des scénarios beaucoup plus complexes, faisant largement usage de tous les goodies qui viennent avec l'enum: itérer sur les instances, en se basant sur leur ordre implicite, extraire une instance par son nom, méthodes statiques fournissant la bonne instance pour des contextes spécifiques, etc. Et pourtant tu as tout cela caché derrière l'interface donc votre code fonctionnera avec des implémentations personnalisées sans modification dans le cas où vous voulez quelque chose qui n'est pas disponible parmi les "options par défaut".

j'ai vu cela appliqué avec succès pour modéliser le concept de granularité temporelle (quotidienne, hebdomadaire, etc.) où toute la logique était encapsulée dans un enum (choix de la granularité adéquate pour un intervalle de temps donné, comportement spécifique lié à chaque granularité comme méthode constante, etc.). Et encore, l' Granularity vu par la couche de service était simplement une interface.

quelque chose qu'aucune autre réponse n'a couvert qui rendent les énums particulièrement puissants sont la capacité d'avoir template methods . Les méthodes peuvent faire partie de l'enum de base et overridden par chaque type. Et, avec le comportement attaché à l'enum, il élimine souvent le besoin de si-else construit ou commute des énoncés comme ce blog démontre - où enum.method() fait ce qui serait à l'origine exécuté à l'intérieur du conditionnel. Le le même exemple montre également l'utilisation des importations statiques avec des enums ainsi produisant beaucoup plus propre DSL comme le code.

D'autres qualités intéressantes incluent le fait que les enum fournissent une implémentation pour equals() , toString() et hashCode() et implémentent Serializable et Comparable .

pour un aperçu complet de tout ce que les enums ont à offrir je recommande fortement de Bruce Eckel pensée en Java 4ème édition qui consacre un chapitre entier à ce sujet. Particulièrement éclairants sont les exemples impliquant une Pierre, Le papier, les ciseaux (c.-à-d. RoShamBo) jeu comme enums.

From Java documents -

vous devez utiliser les types enum chaque fois que vous besoin de représenter un ensemble fixe de constant. Qui comprend l'énum naturel types tels que les planètes dans notre solaire systèmes et ensembles de données où vous savez toutes les valeurs possibles à compiler temps-par exemple, les choix sur un menu, les options de ligne de commande, et ainsi de suite.

un exemple courant est de remplacer une classe par un ensemble des constantes statiques finales int privées (à l'intérieur d'un nombre raisonnable de constantes) avec un type enum. Fondamentalement, si vous pensez que vous connaissez toutes les valeurs possibles de "quelque chose" au moment de la compilation, vous pouvez représenter cela comme un type enum. Les Enums offrent lisibilité et flexibilité sur une classe avec des constantes.

quelques autres avantages que je peux penser de types enum. Ils sont toujours une instance d'une classe d'enum particulière (d'où le concept d'utilisation d'enums comme singleton arrive). Un autre avantage est que vous pouvez utiliser enums comme un type dans la déclaration switch-case. Vous pouvez aussi utiliser toString () sur l'enum pour les imprimer sous forme de chaînes lisibles.

maintenant pourquoi et pourquoi devrais-je utiliser enum dans la programmation quotidienne?

vous pouvez utiliser un Enum pour représenter un petit ensemble fixe de constantes ou un mode de classe interne tout en augmentant la lisibilité. Aussi, les Énumérations peuvent appliquer une certaine rigidité dans les paramètres de la méthode. Ils offrent la possibilité intéressante de transmettre des informations à un constructeur comme dans l'exemple de planètes sur le site D'Oracle et, comme vous avez découvert, aussi permettre un moyen simple de créer un modèle singleton.

ex: Locale.setDefault(Locale.US) se lit mieux que Locale.setDefault(1) et renforce l'utilisation de l'ensemble fixe de valeurs indiqué dans un IDE lorsque vous ajoutez le séparateur . au lieu de tous les entiers.

Enum s énumèrent un ensemble fixe de valeurs, d'une manière auto-documentée.

Ils rendent votre code plus explicite, et aussi moins sujet aux erreurs.

pourquoi ne pas utiliser String , ou int , au lieu de Enum , pour les constantes?

1. le compilateur ne permettra pas typos , ni les valeurs hors de la fixe mis, comme les énums sont types par eux-mêmes. Conséquence:
   • vous n'aurez pas à écrire un pre-condition (ou un manuel if ) pour s'assurer que votre argument est dans la gamme valide.
   • le type invariant est gratuit.
2. Enums peuvent avoir un comportement, comme toute autre classe.
3. vous auriez probablement besoin d'une quantité similaire de mémoire pour utiliser String s, de toute façon (ceci dépend de la complexité du Enum ).

de plus, chacune des instances du Enum est une classe, pour laquelle vous pouvez définir son comportement individuel.

Plus, ils assurent la sécurité du fil lors de la création des instances (lorsque l'enum est chargé), qui a vu une grande application en simplifiant le modèle Singleton .

ce blog illustre certaines de ses applications, comme un Etat Machine pour un analyseur.

il est utile de savoir que enums sont comme les autres classes avec Constant champs et un private constructor .

par exemple,

public enum Weekday
{
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
} 

le compilateur le compile comme suit;

class Weekday extends Enum
{
  public static final Weekday MONDAY  = new Weekday( "MONDAY",   0 );
  public static final Weekday TUESDAY = new Weekday( "TUESDAY ", 1 );
  public static final Weekday WEDNESDAY= new Weekday( "WEDNESDAY", 2 );
  public static final Weekday THURSDAY= new Weekday( "THURSDAY", 3 );
  public static final Weekday FRIDAY= new Weekday( "FRIDAY", 4 );
  public static final Weekday SATURDAY= new Weekday( "SATURDAY", 5 );
  public static final Weekday SUNDAY= new Weekday( "SUNDAY", 6 );

  private Weekday( String s, int i )
  {
    super( s, i );
  }

  // other methods...
}

enum signifie enum

Un enum est un type de données qui contient l'ensemble fixe de constantes.

ou

un enum est comme un class , avec un ensemble fixe d'instances connues au moment de la compilation.

par exemple:

public class EnumExample {
    interface SeasonInt {
        String seasonDuration();
    }

    private enum Season implements SeasonInt {
        // except the enum constants remaining code looks same as class
        // enum constants are implicitly public static final we have used all caps to specify them like Constants in Java
        WINTER(88, "DEC - FEB"), SPRING(92, "MAR - JUN"), SUMMER(91, "JUN - AUG"), FALL(90, "SEP - NOV");

        private int days;
        private String months;

        Season(int days, String months) { // note: constructor is by default private 
            this.days = days;
            this.months = months;
        }

        @Override
        public String seasonDuration() {
            return this+" -> "+this.days + "days,   " + this.months+" months";
        }

    }
    public static void main(String[] args) {
        System.out.println(Season.SPRING.seasonDuration());
        for (Season season : Season.values()){
            System.out.println(season.seasonDuration());
        }

    }
}

avantages de l'enum:

• enum améliore la sécurité du type lors de la vérification de la compilation pour éviter les erreurs lors de l'exécution.
• enum peut être facilement utilisé dans l'interrupteur
• enum peut être parcouru
• enum peut avoir des champs, constructeurs et méthodes
• enum peut implémenter de nombreuses interfaces mais ne peut pas étendre n'importe quelle classe parce qu'elle étend intérieurement la classe Enum

pour plus

mis à part tout ce que disent les autres.. Dans un projet plus ancien pour lequel je travaillais, beaucoup de communication entre les entités(applications indépendantes) utilisait des entiers qui représentaient un petit ensemble. Il était utile de déclarer l'ensemble comme enum avec des méthodes statiques pour obtenir enum objet de value et vice versa. Le code a l'air plus propre, la facilité d'utilisation de cas de commutateur et l'écriture plus facile aux journaux.

enum ProtocolType {
    TCP_IP (1, "Transmission Control Protocol"), 
    IP (2, "Internet Protocol"), 
    UDP (3, "User Datagram Protocol");

    public int code;
    public String name;

    private ProtocolType(int code, String name) {
        this.code = code;
        this.name = name;
    }

    public static ProtocolType fromInt(int code) {
    switch(code) {
    case 1:
        return TCP_IP;
    case 2:
        return IP;
    case 3:
        return UDP;
    }

    // we had some exception handling for this
    // as the contract for these was between 2 independent applications
    // liable to change between versions (mostly adding new stuff)
    // but keeping it simple here.
    return null;
    }
}

créer enum objet de received valeurs (par exemple 1,2) en utilisant ProtocolType.fromInt(2) Écrire aux journaux en utilisant myEnumObj.name

Espérons que cette aide.

Qu'est-ce qu'un enum

• enum est un mot-clé défini pour L'énumération d'un nouveau type de données. Les énumérations de Typesafe doivent être utilisées généreusement. En particulier, ils sont une alternative robuste à la chaîne simple ou des constantes int utilisés dans des API beaucoup plus anciennes pour représenter des ensembles d'éléments connexes.

pourquoi utiliser enum

• les énums sont implicitement des sous-classes finales de java.lang.Enum
• si un enum est un membre d'une classe, il est implicitement statique
• nouveau ne peut jamais être utilisé avec un enum, même dans le type d'enum lui-même
• nom et valeur de simplement utiliser le texte des constantes enum, tandis que toString peut être dépassé pour fournir n'importe quel contenu ,si désiré
• pour les constantes d'enum, égale et = = montant à la même chose, et peut être utilisé de façon interchangeable
• les constantes d'enum sont implicitement publiques statiques final

Note

• les énumérations ne peut pas s'étendre à toute la classe.
• un enum ne peut pas être une superclasse.
• l'ordre d'apparition des enum constantes on appelle leur "ordre naturel", et définit l'ordre utilisé par d'autres éléments: compareTo, l'itération ordre des valeurs, EnumSet, EnumSet.gamme.
• une énumération peut avoir des constructeurs, des blocs statiques et d'instance, des variables, et les méthodes, mais ne peut pas avoir des méthodes abstraites.

enum hérite de toutes les méthodes de Object classe et classe abstraite Enum . Vous pouvez donc utiliser ses méthodes de réflexion, de lecture multiple, de sérilisation, de comparaison, etc. Si vous déclarez une constante statique au lieu d'Enum, vous ne pouvez pas. En outre, la valeur D'Enum peut être transmise à la couche DAO.

Voici un exemple de programme à démontrer.

public enum State {

    Start("1"),
    Wait("1"),
    Notify("2"),
    NotifyAll("3"),
    Run("4"),
    SystemInatilize("5"),
    VendorInatilize("6"),
    test,
    FrameworkInatilize("7");

    public static State getState(String value) {
        return State.Wait;
    }

    private String value;
    State test;

    private State(String value) {
        this.value = value;
    }

    private State() {
    }

    public String getValue() {
        return value;
    }

    public void setCurrentState(State currentState) {
        test = currentState;
    }

    public boolean isNotify() {
        return this.equals(Notify);
    }
}

public class EnumTest {

    State test;

    public void setCurrentState(State currentState) {
        test = currentState;
    }

    public State getCurrentState() {
        return test;
    }

    public static void main(String[] args) {
        System.out.println(State.test);
        System.out.println(State.FrameworkInatilize);
        EnumTest test=new EnumTest();
        test.setCurrentState(State.Notify);
        test. stateSwitch();
    }

    public void stateSwitch() {
        switch (getCurrentState()) {
        case Notify:
            System.out.println("Notify");
            System.out.println(test.isNotify());
            break;
        default:
            break;
        }
    }
}

ENum signifie "type énuméré". C'est un type de données ayant un ensemble fixe de constantes dont vous définissez vous-même.

à mon avis, toutes les réponses que vous avez obtenues jusqu'à présent sont valables, mais d'après mon expérience, je voudrais l'exprimer en quelques mots:

utilisez enums si vous voulez que le compilateur vérifie la validité de la valeur d'un identifiant.

sinon, vous pouvez utiliser des chaînes comme vous l'avez toujours fait (probablement vous avez défini quelques" conventions " pour votre application) et vous serez très flexible... mais vous n'obtiendrez pas 100% de sécurité contre les fautes de frappe vos cordes et vous ne les réaliserez qu'à l'exécution.

Enum? Pourquoi doit-il être utilisé? Je pense que c'est plus compris quand vous l'utiliserez. J'ai la même expérience.

dit que vous avez une opération créer, supprimer, éditer et lire la base de données.

maintenant si vous créez un enum comme une opération:

public enum operation {
    create("1")
    delete("2")
    edit("3")
    read("4")

    // You may have is methods here
    public boolean isCreate() {
        return this.equals(create);
    }
    // More methods like the above can be written

}

Maintenant, vous pouvez déclarer quelque chose comme:

private operation currentOperation;

// And assign the value for it 
currentOperation = operation.create

donc vous pouvez l'utiliser de plusieurs façons. Il est toujours bon d'avoir enum pour des choses spécifiques comme la le fonctionnement de la base de données dans l'exemple ci-dessus peut être contrôlé en cochant la case currentOperation . Peut-être on peut dire ceci peut être accompli avec des variables et des valeurs entières. Mais je crois Qu'Enum est une façon plus sûre et programmatrice.

autre chose: je pense que chaque programmeur aime booléen , n'est-ce pas? Parce qu'il peut stocker que deux valeurs, deux valeurs spécifiques. Donc Enum peut être considéré comme ayant le même type de les installations où un utilisateur définira combien et quel type de valeur il stockera, juste d'une manière légèrement différente. :)

Java vous permet de restreindre la variable à l'une des quelques valeurs prédéfinies - en d'autres termes, une valeur d'une liste énumérée. Utiliser enums peut aider à réduire les bugs dans votre code. Voici un exemple de enums en dehors d'une classe:

enums coffeesize{BIG , HUGE , OVERWHELMING }; 
//This semicolon is optional.

ceci limite coffeesize à avoir soit: BIG , HUGE , ou OVERWHELMING comme variable.

jusqu'à présent, je n'ai jamais eu besoin d'utiliser enums. J'ai lu sur eux depuis qu'ils ont été présentés en 1.5 ou version tigre comme il a été appelé à l'époque. Ils n'ont jamais vraiment résoudre un "problème" pour moi. Pour ceux qui l'utilisent (et je vois beaucoup d'entre eux), je suis sûr qu'il sert incontestablement certains but. Juste mes 2 balles.

il y a beaucoup de réponses ici, je veux juste pointer deux spécifiques:

1) en utilisant comme constantes dans la déclaration Switch-case . Switch case Ne vous permettra pas d'utiliser des objets String pour case. Les enum sont utiles. Lire la suite: http://www.javabeat.net/2009/02/how-to-use-enum-in-switch /

2) La mise en œuvre de Singleton Design Pattern - Enum vient à nouveau à la rescousse. Utilisation, ici: Quelle est la meilleure approche pour utiliser un Enum comme singleton à Java?

ce qui m'a donné le moment Ah-Ha était cette prise de conscience: Qu'Enum a un constructeur privé seulement accessible via l'énumération publique:

enum RGB {
    RED("Red"), GREEN("Green"), BLUE("Blue");

    public static final String PREFIX = "color ";

    public String getRGBString() {
        return PREFIX + color;
    }

    String color;

    RGB(String color) {
        this.color = color;
    }
}

public class HelloWorld {
    public static void main(String[] args) {
        String c = RGB.RED.getRGBString();
        System.out.print("Hello " + c);
    }
}

quant à moi pour rendre le code lisible à l'avenir le cas le plus utile d'énumération aplyable est représenté dans l'extrait suivant:

public enum Items {
    MESSAGES, CHATS, CITY_ONLINE, FRIENDS, PROFILE, SETTINGS, PEOPLE_SEARCH, CREATE_CHAT
}

@Override
public boolean onCreateOptionsMenu(Menu menuPrm) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menuPrm);
    View itemChooserLcl;
    for (int i = 0; i < menuPrm.size(); i++) {
        MenuItem itemLcl  = menuPrm.getItem(i);
            itemChooserLcl = itemLcl.getActionView();
            if (itemChooserLcl != null) {
                 //here Im marking each View' tag by enume values:
                itemChooserLcl.setTag(Items.values()[i]);
                itemChooserLcl.setOnClickListener(drawerMenuListener);
            }
        }
    return true;
}
private View.OnClickListener drawerMenuListener=new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Items tagLcl= (Items) v.getTag();
        switch (tagLcl){
            case MESSAGES: ;
            break;
            case CHATS : ;
            break;
            case CITY_ONLINE : ;
            break;
            case FRIENDS : ;
            break;
            case  PROFILE: ;
            break;
            case  SETTINGS: ;
            break;
            case  PEOPLE_SEARCH: ;
            break;
            case  CREATE_CHAT: ;
            break;
        }
    }
};

utiliser enums pour la sécurité de TYPE, il s'agit d'une caractéristique de langue donc vous obtiendrez généralement:

• support du compilateur (voir immédiatement type issues)
• soutien D'outil dans L'IDEs (auto-completion dans le cas de commutateur ...)

Enums peuvent avoir des méthodes, les constructeurs, vous pouvez même utiliser enums à l'intérieur d'enums et combiner enums avec des interfaces.

pensez aux énums comme types pour remplacer un ensemble bien défini de les constantes int (que Java 'a héritées' de C/C++).

Le livre Effective Java 2nd Edition a un chapitre entier sur eux et qui entre dans plus de détails. Voir aussi ce post de débordement de pile .

d'après mon expérience, J'ai vu que L'utilisation d'Enum rend parfois les systèmes très difficiles à changer. Si vous utilisez un Enum pour un ensemble de valeurs spécifiques à un domaine qui changent fréquemment, et qu'il contient beaucoup d'autres classes et composants qui en dépendent, vous pourriez vouloir considérer et non en utilisant un Enum.

Par exemple, un système d'échange qui utilise un Enum pour les marchés et les échanges. Il ya beaucoup de marchés là-bas et il est presque certain que il y aura beaucoup de sous-systèmes qui devront accéder à cette liste de marchés. Chaque fois que vous voulez qu'un nouveau marché soit ajouté à votre système, ou si vous voulez supprimer un marché, il est possible que tout sous le soleil devra être reconstruit et libéré.

un meilleur exemple serait quelque chose comme un type de catégorie de produit. Disons que votre logiciel gère l'inventaire pour un grand magasin. Il ya beaucoup de catégories de produits, et de nombreuses raisons pour lesquelles cette liste de catégories pourrait changer. Les gestionnaires peuvent vouloir stocker une nouvelle gamme de produits, se débarrasser d'autres gammes de produits, et peut-être réorganiser les catégories de temps en temps. Si vous devez reconstruire et redéployer tous vos systèmes simplement parce que les utilisateurs veulent ajouter une catégorie de produits, alors vous avez pris quelque chose qui devrait être simple et rapide (Ajout d'une catégorie) et rendu très difficile et lent.

ligne de fond, les Énums sont bons si les données que vous représentez est très statique dans le temps et a un nombre limité de dépendances. Mais si les données changent beaucoup et ont beaucoup de dépendances, alors vous avez besoin de quelque chose de dynamique qui n'est pas vérifié au moment de la compilation (comme une table de base de données).

je voudrais utiliser les énumérations comme un utile instrument de cartographie, en évitant les multiples if-else à condition que certaines méthodes soient appliquées.

public enum Mapping {

    ONE("1"),
    TWO("2");

    private String label;

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

    public static Mapping by(String label) {

        for(Mapping m: values() {
            if(m.label.equals(label)) return m;
        }

        return null;
    }

}

ainsi la méthode by(String label) vous permet d'obtenir la valeur énumérée par non-énuméré. En outre, on peut inventer la cartographie entre 2 énums. Pourrait également essayer "1 à beaucoup" ou "beaucoup à beaucoup" en plus de "one to one" relation par défaut

à la fin, enum est une classe Java. De sorte que vous pouvez avoir main méthode à l'intérieur de celui-ci, qui pourrait être utile lors de la nécessité de faire certaines opérations de cartographie sur args tout de suite.