Quel est l'avantage d'une énumération Java par rapport à une classe avec des champs finaux statiques publics?

Je connais très bien le C # mais je commence à travailler davantage en Java. Je m'attendais à apprendre que les énumérations en Java étaient fondamentalement équivalentes à celles en C # mais apparemment ce n'est pas le cas. Au départ, j'étais ravi d'apprendre que les énumérations Java pouvaient contenir plusieurs éléments de données, ce qui semble très avantageux ( http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html ). Cependant, depuis lors, j'ai trouvé de nombreuses fonctionnalités manquantes qui sont triviales en C #, telles que la possibilité d'attribuer facilement à un élément enum une certaine valeur, et par conséquent la possibilité de convertir un entier en enum sans un effort décent ( c'est-à-dire Convertir une valeur entière en Java Enum correspondant ).

Ma question est donc la suivante: y a-t-il un avantage aux énumérations Java par rapport à une classe avec un tas de champs finaux statiques publics? Ou fournit-il simplement une syntaxe plus compacte?

EDIT: Permettez-moi d'être plus clair. Quel est l'avantage des énumérations Java sur une classe avec un tas de champs finaux statiques publics du même type ? Par exemple, dans l'exemple des planètes au premier lien, quel est l'avantage d'une énumération sur une classe avec ces constantes publiques:

public static final Planet MERCURY = new Planet(3.303e+23, 2.4397e6);
public static final Planet VENUS = new Planet(4.869e+24, 6.0518e6);
public static final Planet EARTH = new Planet(5.976e+24, 6.37814e6);
public static final Planet MARS = new Planet(6.421e+23, 3.3972e6);
public static final Planet JUPITER = new Planet(1.9e+27, 7.1492e7);
public static final Planet SATURN = new Planet(5.688e+26, 6.0268e7);
public static final Planet URANUS = new Planet(8.686e+25, 2.5559e7);
public static final Planet NEPTUNE = new Planet(1.024e+26, 2.4746e7);

Pour autant que je sache, la réponse de casablanca est la seule qui satisfait à cela.

Techniquement, on pourrait en effet voir les énumérations comme une classe avec un tas de constantes typées, et c'est en fait ainsi que les constantes enum sont implémentées en interne. enumCependant, l' utilisation d'un vous donne des méthodes utiles ( Enum javadoc ) que vous auriez autrement à implémenter vous-même, telles que Enum.valueOf.

1. Sécurité de type et sécurité de valeur.
2. Singleton garanti.
3. Capacité à définir et à remplacer des méthodes.
4. Capacité d'utiliser des valeurs dans switchinstruction des casedéclarations sans réserve.
5. Séquentialisation intégrée des valeurs via ordinal().
6. Sérialisation par nom et non par valeur, ce qui offre un certain degré de pérennité.
7. EnumSetet les EnumMapclasses.

Personne n'a mentionné la possibilité de les utiliser dans les switchdéclarations; Je vais ajouter cela aussi.

Cela permet d'utiliser des énumérations arbitrairement complexes d'une manière propre sans utiliser de séquences instanceofpotentiellement déroutantes ifou de valeurs de commutation non-string / int. L'exemple canonique est une machine à états.

Le principal avantage est la sécurité du type. Avec un ensemble de constantes, toute valeur du même type intrinsèque pourrait être utilisée, introduisant des erreurs. Avec une énumération, seules les valeurs applicables peuvent être utilisées.

Par exemple

public static final int SIZE_SMALL  = 1;
public static final int SIZE_MEDIUM = 2;
public static final int SIZE_LARGE  = 3;

public void setSize(int newSize) { ... }

obj.setSize(15); // Compiles but likely to fail later

contre

public enum Size { SMALL, MEDIUM, LARGE };

public void setSize(Size s) { ... }

obj.setSize( ? ); // Can't even express the above example with an enum

Il y a moins de confusion. Prenons Fontpar exemple. Il a un constructeur qui prend le nom de celui que Fontvous voulez, sa taille et son style ( new Font(String, int, int)). À ce jour, je ne me souviens pas si le style ou la taille passe en premier. Si Fontavait utilisé un enumpour tous ses différents styles ( PLAIN, BOLD, ITALIC, BOLD_ITALIC), son constructeur ressemblerait Font(String, Style, int), ce qui empêche toute confusion. Malheureusement, il enumn'y en avait pas lorsque la Fontclasse a été créée, et puisque Java doit maintenir la compatibilité inverse, nous serons toujours en proie à cette ambiguïté.

Bien sûr, ce n'est qu'un argument pour utiliser un enumau lieu de public static finalconstantes. Les énumérations sont également parfaites pour les singletons et implémentent un comportement par défaut tout en permettant une personnalisation ultérieure (IE le modèle de stratégie ). Un exemple de ce dernier est java.nio.file's OpenOptionet StandardOpenOption: si un développeur voulait créer son propre non-standard OpenOption, il le pourrait.

Il y a beaucoup de bonnes réponses ici, mais aucune ne mentionne qu'il existe des implémentations hautement optimisées des classes / interfaces de l'API Collection spécifiquement pour les énumérations :

• EnumSet
• EnumMap

Ces classes spécifiques à une énumération n'acceptent que les Enuminstances (les EnumMapseules acceptent les Enums uniquement comme clés), et chaque fois que possible, elles reviennent à une représentation compacte et à la manipulation de bits dans leur implémentation.

Qu'est-ce que ça veut dire?

Si notre Enumtype n'a pas plus de 64 éléments (la plupart des Enumexemples réels seront qualifiés pour cela), les implémentations stockent les éléments dans une seule longvaleur, chaque Enuminstance en question sera associée à un peu de cette longueur de 64 bits long. Ajouter un élément à un EnumSetest simplement définir le bit approprié à 1, le supprimer revient simplement à mettre ce bit à 0. Tester si un élément est dans le Setest juste un test de masque de bits! Maintenant tu dois aimer Enumça!

exemple:

public class CurrencyDenom {
   public static final int PENNY = 1;
 public static final int NICKLE = 5;
 public static final int DIME = 10;
public static final int QUARTER = 25;}

Limitation des constantes Java

1) Pas de sécurité de type : tout d'abord, ce n'est pas de type sûr; vous pouvez attribuer n'importe quelle valeur int valide à int, par exemple 99 bien qu'il n'y ait pas de pièce pour représenter cette valeur.

2) Aucune impression significative : l'impression de la valeur de l'une de ces constantes imprimera sa valeur numérique au lieu du nom significatif de la pièce, par exemple lorsque vous imprimez NICKLE, il imprimera "5" au lieu de "NICKLE"

3) Pas d'espace de noms : pour accéder à la constante currencyDenom, nous devons préfixer le nom de la classe, par exemple CurrencyDenom.PENNY au lieu d'utiliser simplement PENNY bien que cela puisse également être réalisé en utilisant l'importation statique dans JDK 1.5

Avantage d'énumération

1) Les énumérations en Java sont de type sécurisé et ont leur propre espace de nom. Cela signifie que votre énumération aura un type par exemple "Devise" dans l'exemple ci-dessous et que vous ne pouvez attribuer aucune valeur autre que celle spécifiée dans Constantes Enum.

public enum Currency {PENNY, NICKLE, DIME, QUARTER};

Currency coin = Currency.PENNY; coin = 1; //compilation error

2) Enum en Java est un type de référence comme la classe ou l'interface et vous pouvez définir un constructeur, des méthodes et des variables dans java Enum, ce qui le rend plus puissant que Enum en C et C ++ comme indiqué dans l'exemple suivant de type Java Enum.

3) Vous pouvez spécifier les valeurs des constantes d'énumération au moment de la création comme indiqué dans l'exemple ci-dessous: public enum Currency {PENNY (1), NICKLE (5), DIME (10), QUARTER (25)}; Mais pour que cela fonctionne, vous devez définir une variable membre et un constructeur car PENNY (1) appelle en fait un constructeur qui accepte la valeur int, voir l'exemple ci-dessous.

public enum Currency {
    PENNY(1), NICKLE(5), DIME(10), QUARTER(25);
    private int value;

    private Currency(int value) {
            this.value = value;
    }
}; 

Référence: https://javarevisited.blogspot.com/2011/08/enum-in-java-example-tutorial.html

Le premier avantage des énumérations, comme vous l'avez déjà remarqué, est la simplicité de la syntaxe. Mais le point principal des énumérations est de fournir un ensemble bien connu de constantes qui, par défaut, forment une plage et aident à effectuer une analyse de code plus complète grâce à des contrôles de sécurité de type et de valeur.

Ces attributs d'énumérations aident à la fois un programmeur et un compilateur. Par exemple, disons que vous voyez une fonction qui accepte un entier. Que pourrait signifier cet entier? Quel genre de valeurs pouvez-vous transmettre? Vous ne savez pas vraiment tout de suite. Mais si vous voyez une fonction qui accepte enum, vous connaissez très bien toutes les valeurs possibles que vous pouvez transmettre.

Pour le compilateur, les énumérations aident à déterminer une plage de valeurs et à moins que vous n'assigniez des valeurs spéciales aux membres d'énumération, elles sont bien comprises entre 0 et plus. Cela permet de détecter automatiquement les erreurs dans le code grâce à des contrôles de sécurité de type et plus encore. Par exemple, le compilateur peut vous avertir que vous ne gérez pas toutes les valeurs d'énumération possibles dans votre instruction switch (c'est-à-dire lorsque vous n'avez pas de defaultcasse et ne gérez qu'une seule valeur d'énumération sur N). Il vous avertit également lorsque vous convertissez un entier arbitraire en enum car la plage de valeurs d'énumération est inférieure à celle d'un entier et cela peut à son tour déclencher des erreurs dans la fonction qui n'accepte pas vraiment un entier. En outre, la génération d'une table de saut pour le commutateur devient plus facile lorsque les valeurs sont comprises entre 0 et plus.

Ce n'est pas seulement vrai pour Java, mais aussi pour d'autres langages avec une vérification de type stricte. C, C ++, D, C # sont de bons exemples.

Un ENUM est implictly finale, avec les constructeurs privés, toutes ses valeurs sont du même type ou un sous-type, vous pouvez obtenir toutes ses valeurs à l' aide values(), obtient sa name()ou ordinal()valeur ou vous pouvez rechercher un ENUM par numéro ou le nom.

Vous pouvez également définir des sous-classes (même si elles sont théoriquement finales, ce que vous ne pouvez pas faire autrement)

enum Runner implements Runnable {
    HI {
       public void run() {
           System.out.println("Hello");
       }
    }, BYE {
       public void run() {
           System.out.println("Sayonara");
       }
       public String toString() {
           return "good-bye";
       }
    }
 }

 class MYRunner extends Runner // won't compile.

enum Avantages:

1. Les énumérations sont de type sécurisé, les champs statiques ne le sont pas
2. Il existe un nombre fini de valeurs (il n'est pas possible de transmettre une valeur d'énumération non existante. Si vous avez des champs de classe statiques, vous pouvez faire cette erreur)
3. Chaque énumération peut avoir plusieurs propriétés (champs / getters) assignées - encapsulation. Aussi quelques méthodes simples: YEAR.toSeconds () ou similaire. Comparez: Colors.RED.getHex () avec Colors.toHex (Colors.RED)

"comme la possibilité d'attribuer facilement à un élément enum une certaine valeur"

enum EnumX{
  VAL_1(1),
  VAL_200(200);
  public final int certainValue;
  private X(int certainValue){this.certainValue = certainValue;}
}

"et par conséquent la possibilité de convertir un entier en enum sans un effort décent" Ajouter une méthode convertissant int en enum qui fait cela. Ajoutez simplement HashMap statique <Integer, EnumX> contenant l' énumération java de mappage .

Si vous voulez vraiment convertir ord = VAL_200.ordinal () en val_200, utilisez simplement: EnumX.values ​​() [ord]

Une autre différence importante est que le compilateur java traite les static finalchamps de types primitifs et String comme des littéraux. Cela signifie que ces constantes deviennent en ligne. C'est similaire au C/C++ #definepréprocesseur. Voir cette question SO . Ce n'est pas le cas avec les énumérations.

Vous obtenez une vérification à la compilation des valeurs valides lorsque vous utilisez une énumération. Regardez cette question.

Le plus grand avantage est que les singletons enum sont faciles à écrire et sécurisés pour les threads:

public enum EasySingleton{
    INSTANCE;
}

et

/**
* Singleton pattern example with Double checked Locking
*/
public class DoubleCheckedLockingSingleton{
     private volatile DoubleCheckedLockingSingleton INSTANCE;

     private DoubleCheckedLockingSingleton(){}

     public DoubleCheckedLockingSingleton getInstance(){
         if(INSTANCE == null){
            synchronized(DoubleCheckedLockingSingleton.class){
                //double checking Singleton instance
                if(INSTANCE == null){
                    INSTANCE = new DoubleCheckedLockingSingleton();
                }
            }
         }
         return INSTANCE;
     }
}

les deux sont similaires et ont géré la sérialisation par eux-mêmes en implémentant

//readResolve to prevent another instance of Singleton
    private Object readResolve(){
        return INSTANCE;
    }

plus

Je pense qu'un enumne peut pas être final, car sous le capot, le compilateur génère des sous-classes pour chaqueenum entrée.

Plus d'informations De la source

Les énumérations affichées ici présentent de nombreux avantages et je crée actuellement de telles énumérations, comme demandé dans la question. Mais j'ai une énumération avec 5-6 champs.

enum Planet{
EARTH(1000000, 312312321,31232131, "some text", "", 12),
....
other planets
....

Dans ce genre de cas, lorsque vous avez plusieurs champs dans les énumérations, il est beaucoup plus difficile de comprendre quelle valeur appartient à quel champ car vous avez besoin de voir le constructeur et le globe oculaire.

La classe avec des static finalconstantes et l'utilisation d'un Buildermodèle pour créer de tels objets le rendent plus lisible. Mais, vous perdriez tous les autres avantages de l'utilisation d'une énumération, si vous en avez besoin. Un inconvénient de ces classes est, vous devez ajouter les Planetobjets manuellement à list/setdesPlanets.

Je préfère toujours enum à une telle classe, car c'est values()pratique et vous ne savez jamais si vous en avez besoin pour l'utiliser dans switchou EnumSetou EnumMapà l'avenir :)

Raison principale: les énumérations vous aident à écrire du code bien structuré où la signification sémantique des paramètres est claire et fortement typée au moment de la compilation - pour toutes les raisons que d'autres réponses ont données.

Quid pro quo: en Java prêt à l'emploi, le tableau des membres d'un Enum est définitif. C'est normalement bien car cela aide à valoriser la sécurité et les tests, mais dans certaines situations, cela pourrait être un inconvénient, par exemple si vous étendez le code de base existant peut-être à partir d'une bibliothèque. En revanche, si les mêmes données sont dans une classe avec des champs statiques, vous pouvez facilement ajouter de nouvelles instances de cette classe au moment de l'exécution (vous devrez peut-être également écrire du code pour les ajouter à tout Iterable que vous avez pour cette classe). Mais ce comportement d'Enums peut être changé: en utilisant la réflexion, vous pouvez ajouter de nouveaux membres à l'exécution ou remplacer des membres existants, bien que cela ne devrait probablement être fait que dans des situations spécialisées où il n'y a pas d'alternative: c'est-à-dire que c'est une solution piratée et peut produire des problèmes inattendus, voir ma réponse surPuis-je ajouter et supprimer des éléments d'énumération lors de l'exécution en Java .