concept
Le nom complet d' enum est l'énumération, qui est une nouvelle fonctionnalité introduite dans JDK 1.5.
En Java, le type modifié par enum est le type d'énumération. Le formulaire est le suivant:
Enum Couleur {rouge, vert, bleu}Si l'énume n'entre aucune méthode, la valeur de l'énume est par défaut à une valeur commandée à partir de 0. En prenant le type d'énumération de couleur comme exemple, ses constantes de dénombrement sont rouges: 0, vert: 1 et bleu: 2 en séquence
Les avantages de l'énumération: les constantes peuvent être organisées et gérées de manière unifiée.
Scénarios d'application typiques pour l'énumération: codes d'erreur, machines d'état, etc.
La nature des types d'énumération
Bien que enum ressemble à un nouveau type de données, Enum est en fait une classe restreinte et a sa propre méthode.
Lors de la création d'une énumération, le compilateur générera une classe connexe pour vous, qui est hérité de java.lang.Enum .
Déclaration de classe java.lang.Enum
Classe de résumé public enum <e étend enum <e>> implémente comparable <e>, sérialisable {...}Méthodes d'énumération
Dans Enum, certaines méthodes de base sont fournies:
values() : Renvoie un tableau d'instances d'énumération, et les éléments de ce tableau sont strictement maintenus dans l'ordre elles sont déclarées en énumération.
name() : renvoie le nom de l'instance.
ordinal() : Renvoie l'ordre lorsque l'instance est déclarée, à partir de 0.
getDeclaringClass() : renvoie le type d'énumération auquel appartient l'instance.
equals() : détermine s'il s'agit du même objet.
Vous pouvez utiliser == pour comparer les instances enum .
De plus, java.lang.Enum implémente les interfaces Comparable et Serializable , de sorte que la méthode compareto () est également fournie.
Exemple: méthodes de base pour afficher l'énumération
classe publique EnumthodDemo {enum couleur {rouge, vert, bleu;} taille de l'énume {grand, milieu, petit;} public static void main (String args []) {System.out.println ("=============. ===================================================================. System.out.println ("============= Imprimer toute la taille ====================================================================================. Color.Green; Color.Green: "+ Green.equals (Color.Green)); System.out.println (" Green équivaut à size.middle: "+ vert.equals (size.middle)); System.out.println (" Green équivaut à 1: "+ Green.equals (1)); System.out.Format (" Green == Color.Blue:% b / n ", green ==. }}Sortir
============================. getDeclarenClass (): class org.zp.javase.enumeration.enumdemo $ colorgreen hashcode (): 460141958Green compareto couleur.Green: 0Green est égal à Color.Green: TrueGreen est l'équilibre
Caractéristiques de l'énumération
Les caractéristiques de l'énumération sont résumées en une phrase:
En plus d'être incapable de hériter, enum peut essentiellement être considérée comme une classe ordinaire.
Mais cette phrase doit être comprise séparément, expliquons-le en détail.
L'énumération peut ajouter des méthodes
Dans le chapitre du concept, la valeur d'énumération par défaut est une valeur commandée à partir de 0. Ensuite, la question est: comment attribuer des valeurs à l'énumération affichée.
Java n'autorise pas l'utilisation des valeurs de = affecter des constantes d'énumération
Si vous avez été exposé à C / C ++, vous penserez certainement au symbole de l'affectation = naturellement. Dans la langue C / C ++, l'énumération peut être affectée aux constantes de l'énumération avec le symbole d'attribution = affiché; Cependant, malheureusement, le symbole d'attribution = attribué aux constantes d'énumération n'est pas autorisé dans la syntaxe Java.
Exemple: Déclaration d'énumération en langue C / C ++
typedef enum {one = 1, deux, trois = 3, dix = 10} numéro;L'énuo peut ajouter des méthodes ordinaires, des méthodes statiques, des méthodes abstraites et des méthodes de constructeur.
Bien que Java ne puisse pas attribuer directement des valeurs aux instances, il a une solution encore meilleure: ajoutez des méthodes à ENUM pour implémenter indirectement les affectations d'affichage.
Lors de la création enum , vous pouvez y ajouter plusieurs méthodes, et même des constructeurs.
Remarquez un détail: si vous souhaitez définir une méthode pour une énumération, vous devez ajouter un point-virgule à la fin de la dernière instance de l'énumération. De plus, dans ENUM, l'instance doit être définie en premier et les champs ou les méthodes ne peuvent pas être définis avant l'instance. Sinon, le compilateur rapportera une erreur.
Exemple: Montrez pleinement comment définir des méthodes ordinaires, des méthodes statiques, des méthodes abstraites et des méthodes de construction dans les énumérations
public Enum errorCode {ok (0) {public String getDescription () {return "réussi"; }}, Error_a (100) {public String getDescription () {return "error a"; }}, Error_b (200) {public String getDescription () {return "error b"; }}; code int privé; // Constructeur: Le constructeur d'Enum ne peut être déclaré que comme autorisation privée ou ne déclare pas l'autorisation Private ErrorCode (int } public int getcode () {// Méthode ordinaire Code de retour; } // Méthode ordinaire Public Résumé String GetDescription (); // Méthode abstraite public static void main (String args []) {// Méthode statique pour (errorcode s: errorcode.values ()) {System.out.println ("code:" + s.getcode () + ", description:" + s.getDescription ()); }}}Remarque: L'exemple ci-dessus n'est pas conseillé, juste pour montrer que l'énumération prend en charge la définition de diverses méthodes. Voici un exemple simplifié
Exemple: définition d'un type de dénombrement de code d'erreur
Les résultats d'exécution de cet exemple et l'exemple ci-dessus sont exactement les mêmes.
public Enum errorCodeen {ok (0, "Success"), error_a (100, "error a"), error_b (200, "error b"); ErrorCodeen (int nombre, string Description) {this.code = nombre; this.description = description; } Code int privé; Description de la chaîne privée; public int getcode () {return code; } public String getDescription () {return Description; } public static void main (String args []) {// méthode statique pour (errorCodeen s: errorCodeen.values ()) {System.out.println ("code:" + s.getcode () + ", description:" + s.getDescription ()); }}}L'énumération peut implémenter les interfaces
enum peut implémenter des interfaces comme les classes générales.
Il implémente également la classe d'énumération du code d'erreur dans la section précédente. En implémentant l'interface, il peut limiter ses méthodes.
Interface publique inumberEnum {int getcode (); String getDescription ();} public Enum errorCodeen2 implémente inumberEnum {ok (0, "Success"), error_a (100, "error a"), error_b (200, "error b"); ErrorCodeen2 (int nombre, string Description) {this.code = nombre; this.description = description; } Code int privé; Description de la chaîne privée; @Override public int getcode () {return code; } @Override public String getDescription () {return Description; }}L'énumération ne peut pas être héritée
L'énuo ne peut pas hériter d'une autre classe, et bien sûr, il ne peut pas hériter d'une autre énumération.
Parce que enum sont réellement héritées de java.lang.Enum , et Java ne prend pas en charge l'héritage multiple, l'énume ne peut pas hériter d'autres classes, et bien sûr, il ne peut pas hériter d'une autre enum .
Scénarios d'application énumérés
Organiser les constantes
Avant JDK1.5, la définition des constantes en Java était public static final TYPE a ; sous cette forme. Avec des énumérations, vous pouvez organiser des constantes d'associations pour rendre le code plus lisible et sûr, et également utiliser les méthodes fournies par les énumérations.
Format de déclaration d'énumération
Remarque: S'il n'y a pas de méthode définie dans l'énumération, vous pouvez également ajouter une virgule, un demi-colon ou rien après la dernière instance.
Les trois méthodes de déclaration suivantes sont équivalentes:
Couleur d'énumération {rouge, vert, bleu} couleur enum {rouge, vert, bleu,} couleur enum {rouge, vert, bleu; }Commutation de la machine d'état
Nous utilisons souvent des instructions de commutation pour écrire des machines d'état. Après JDK7, Switch a pris en charge les paramètres des types int、char、String、enum . Par rapport à ces types de paramètres, le code de commutation à l'aide d'énumérations est plus lisible.
Signal Enum {rouge, jaune, vert} String statique public getTrafficInstruct (signal de signal) {String instruct = "Signal Light Faiche"; switch (signal) {case rouge: instruct = "rouge stop"; casser; Case jaune: instruct = "Veuillez faire attention à la lumière jaune"; casser; Case vert: instruct = "Green Light Line"; casser; par défaut: pause; } retour instruct;}Organiser l'énumération
Des énumérations de types similaires peuvent être organisées via des interfaces ou des classes.
Cependant, il est généralement organisé par interface.
La raison en est: l'interface Java ajoutera automatiquement le modificateur public static au type d'énumération lors de la compilation; La classe Java ajoutera automatiquement le modificateur static au type d' enum lors de la compilation. Avez-vous vu la différence? C'est vrai, c'est-à-dire organiser enum dans la classe. Si vous ne le modifiez pas en public , vous ne pouvez y accéder que dans ce package.
Exemple: organiser les énumérations dans les interfaces
Interface publique Plant {Enum Vegetable Implémentez inumberRenum {Potato (0, "Potato"), Tomato (0, "Tomato"); Vegetable (numéro int, description de la chaîne) {this.code = nombre; this.description = description; } Code int privé; Description de la chaîne privée; @Override public int getcode () {return 0; } @Override public String getDescription () {return null; }} Enum Fruit implémente inumberEnum {Apple (0, "Apple"), Orange (0, "Orange"), Banana (0, "banane"); Fruit (int n °, description de la chaîne) {this.code = numéro; this.description = description; } Code int privé; Description de la chaîne privée; @Override public int getcode () {return 0; } @Override public String getDescription () {return null; }}}Exemple: organiser les énumérations dans une classe
Cet exemple a le même effet que l'exemple précédent.
classe publique Plant2 {public Enum Vegetable Implémentez InumberRenum {...} // omettre le code Public Enum fruit implémente inumberEnum {...} // omettre le code}Énumération de stratégie
Une énumération de la stratégie est montrée dans Java efficace. Cette énumération classe les constantes d'énumération par énumération énumérée.
Bien que cette approche ne soit pas aussi concise que l'instruction Switch, elle est plus sûre et plus flexible.
Exemple: Exemple d'énumération des politiques dans Effectviejava
Enum Payrollday {lundi (PayType.Weekday), mardi (PayType.Weekday), mercredi (PayType.Weekday), jeudi (PayType.Deekday), vendredi (PayType.Weekday); PayType final privé PayType; Payrollday (PayType PayType) {this.payType = PayType; } Double Pay (Double HourSweked, Double Payrate) {RETOUR PAYTYPE.PAY (HourSwed, Payrate); } // Policy Enum private enum PayType {Weekday {double overtimePay (heures doubles, double rémunération) {Heures de retour <= heures_per_shift? 0: (heures - heures_per_shift) * Payrate / 2; }}, Week-end {double overtimePay (heures doubles, double rémunération) {heures de retour * Payrate / 2; }}; private static final int hours_per_shift = 8; Résumé Double OvertimePay (Double HR, Double Payrate); Double salaire (Double Hoursworked, Double Payrate) {Double BasEpay = HourSworked * Payrate; RETOUR BASEPAY + TRANSIMEPAY (HourSweked, Payrate); }}}test
System.out.println ("Géré pour les personnes qui gagnent 100 le salaire horaire vendredi pendant 8 heures:" + Payrollday.friday.pay (8.0, 100)); System.out.println ("Géré pour les personnes qui gagnent 100 le salaire horaire samedi pendant 8 heures:" + Payrollday.Saturday.pay (8.0, 100));Énumaire et énumap
Java fournit deux classes d'outils qui sont pratiques pour le fonctionnement de l'énumération - Enumset et Enuummap.
EnumSet est une implémentation Set haute performance des types d'énumération. Il faut que les constantes d'énumération placées dedans soient appartenir au même type d'énumération.
EnumMap est une implémentation de carte adaptée aux types d'énumération. Bien que l'utilisation d'autres implémentations Map (telles que HashMap) puisse également effectuer des instances de type énum pour le mappage de valeur, l'utilisation d'Enuummap est plus efficace: elle ne peut recevoir que des instances du même type d'énumération que les valeurs clés, et parce que le nombre d'instances de type d'énumération est relativement fixe et limité, ENUMMAP utilise un tableau pour stocker les valeurs correspondant au type ENUM. Cela rend Énumap très efficace.
// Utilisation de Enumset System.out.println ("Enumset Display"); enumset <RerrorCodeen> errSet = enumSet.Allof (errorCodeen.class); for (errorCodeen e: errSet) {System.out.println (e.name () + ":" + e.ordinal ());} // Utilisation de edummap System.out.println ("Entummap Display"); edummap <StateMachine.signal, String> errmap = new Enuummap (Statemachine.signal.class); errmap.put (Statemachine.signal.red, "Red Light"); errmap.put (statemachine.signal.yellow, "jaune"); errmap.put (statemachine.signal.green, "Green Light"); pour (iterator <map.Entry <Statemachine.Signal, green> iter = iterator <Map.Entry <Statemachine.Signal, Sinder = Iterreat errmap.entryset (). iterator (); iter.hasnext ();) {map.entry <stateMachine.signal, string> entrée = iter.next (); System.out.println (entry.getKey (). Name () + ":" + entry.getValue ());}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.