1. Contexte
Avant l'introduction de la langue Java, le modèle commun pour indiquer un type d'énumération est de déclarer un ensemble de constantes int. Le code que nous avons utilisé pour définir avant d'utiliser la méthode statique finale publique est la suivante, en utilisant 1 pour représenter le printemps, 2 pour représenter l'été, 3 pour représenter l'automne et 4 pour représenter l'hiver.
Saison de classe publique {public static final int printemps = 1; public statique final int été = 2; public static final int automne = 3; public static final int hiver = 4;}Cette méthode est appelée le modèle d'énumération int. Mais qu'est-ce qui ne va pas avec ce modèle? Nous l'avons utilisé depuis si longtemps, donc il ne devrait y avoir aucun problème. Habituellement, le code que nous écrivons prend en compte sa sécurité, sa facilité d'utilisation et sa lisibilité. Tout d'abord, considérons sa sécurité de type. Bien sûr, ce modèle n'est pas de type type. Par exemple, nous concevons une fonction qui nécessite une certaine valeur au printemps, en été, en automne et en hiver. Cependant, avec le type int, nous ne pouvons garantir que la valeur adoptée est légale. Le code ressemble à ceci:
private String getChineSeason (int saison) {stringBuffer result = new StringBuffer (); switch (saison) {case saison.spring: result.append ("printemps"); casser; Case Saison.Summer: Result.APPEND ("Summer"); casser; case saison.automn: result.append ("automne"); casser; Saison de cas.winter: result.append ("hiver"); casser; par défaut: result.append ("Saison Aucun sur Terre"); casser; } return result.toString (); } public void doSomething () {System.out.println (this.getChinesEseason (season.spring)); // Il s'agit d'un scénario normal System.out.println (this.getCheneseason (5)); // Il s'agit d'un scénario anormal, qui mène à taper des problèmes d'insécurité}Le programme GetChineseason (saison.spring) est la méthode que nous prévoyons d'utiliser. Mais GetChinesseason (5) n'est évidemment pas le cas, et la compilation est très passive. Nous ne savons pas ce qui se passe lors de l'exécution. Cela ne se conforme évidemment pas à la sécurité des programmes Java.
Ensuite, considérons la lisibilité de ce modèle. La plupart des occasions lors de l'utilisation d'énumérations, je dois être pratique pour obtenir des expressions de chaîne de type énumération. Si nous imprimons les constantes d'énumération int, ce que nous voyons est un ensemble de nombres, ce qui n'est pas très utile. Nous pouvons penser à utiliser des constantes de chaîne au lieu des constantes int. Bien qu'il fournit des chaînes imprimables pour ces constantes, elle provoque des problèmes de performance, car il repose sur les opérations de comparaison des chaînes, donc ce modèle est également quelque chose que nous ne nous attendons pas. Compte tenu de la sécurité du type et de la lisibilité du programme, les inconvénients des modèles d'énumération INT et STRING sont révélés. Heureusement, depuis la version Java 1.5, une autre solution alternative a été proposée qui évite les inconvénients des modèles d'énumération INT et STRING et offre de nombreux avantages supplémentaires. C'est le type d'énumération. Les chapitres suivants présenteront les définitions, les fonctionnalités, les scénarios d'application et les avantages et les inconvénients des types d'énumération.
2. Définition <r /> Le type d'énumération fait référence à un type juridique composé d'un ensemble fixe de constantes. En Java, l'énumération du mot-clé est utilisée pour définir un type d'énumération. Ce qui suit est la définition du type d'énumération Java.
Saison de l'énumération publique {printemps, été, automne, cavalier;} 3. Caractéristiques
Les déclarations de Java qui définissent les types d'énumération sont très simples. Il a les caractéristiques suivantes:
1) Utilisez le mot clé Enum 2) le nom de type, tel que la saison 3) Une chaîne de valeurs autorisées, telles que le printemps, l'été, l'automne, l'hiver et les saisons définies ci-dessus 4) les énumérations peuvent être définies séparément dans un fichier ou intégrées dans d'autres classes Java.
En plus de ces exigences de base, les utilisateurs ont d'autres options
5) Les énumérations peuvent implémenter une ou plusieurs interfaces (interfaces) 6) De nouvelles variables peuvent être définies 7) La nouvelle méthode peut être définie 8) les classes qui varient en fonction des valeurs d'énumération spécifiques peuvent être définies
4. Scénarios d'application
Prenant la sécurité du type mentionné dans l'arrière-plan à titre d'exemple, réécrivez ce code avec un type d'énumération. Le code est le suivant:
Saison d'énumération publique {printemps (1), été (2), automne (3), hiver (4); code int privé; Saison privée (int Code) {this.code = code; } public int getcode () {return code; }} Classe publique USE-saison {/ ** * Convertir la saison anglaise en saison chinoise * @param saison * @return * / public String getCHINESEASH (saison de saison) {StringBuffer result = new StringBuffer (); switch (saison) {case printemps: result.append ("[chinois: printemps, constante d'énumération:" + saison.name () + ", data:" + saison.getcode () + "]"); casser; Case Automne: result.append ("[chinois: automne, constante de dénombrement:" + saison.name () + ", data:" + saison.getcode () + "]"); casser; Case Summer: Result.APPEND ("[Chinois: été, constante de dénombrement:" + saison.name () + ", données:" + saison.getcode () + "]"); casser; Case hiver: résultat.APPEND ("[Chinois: hiver, constantes d'énumération:" + saison.name () + ", données:" + saison.getcode () + "]"); casser; Par défaut: result.append ("Saison sans Terre" + saison.name ()); casser; } return result.toString (); } public void doSomething () {for (saison s: saison.values ()) {System.out.println (getCheseseason (s)); // Ceci est un scénario normal} //system.out.println(getCheneSesEason Season(5)); // Le compilateur échoue déjà ici, qui garantit la sécurité de type} public static void main (String [] arg) {useason useason = new use-season (); use-saison.dosomething (); }}[Chinois: printemps, énumération constante: printemps, données: 1] [Chinois: été, énumération constante: été, données: 2] [chinois: automne, énumération constante: automne, données: 3] [chinois: hiver, énumération constante: hiver, données: 4]
Voici une question, pourquoi est-ce que je veux ajouter le domaine au type d'énumération? Le but est d'associer les données à ses constantes. Par exemple, 1 représente le printemps et 2 représente l'été.
5. Résumé
Alors, quand devriez-vous utiliser des énumérations? Chaque fois qu'un ensemble fixe de constantes est nécessaire, comme les jours d'une semaine, les saisons de l'année, etc. ou une collection de toutes les valeurs qu'elle contient avant de compiler. L'énumération Java 1.5 peut répondre aux exigences de la plupart des programmeurs, et ses caractéristiques concises et faciles à utiliser sont très importantes.
6. Utilisation
Utilisation 1: constante
Couleur de l'énumération publique {rouge, vert, vierge, jaune}Utilisation 2: Commutation
Enum Signal {vert, jaune, rouge} classe publique Trafficlight {signal color = signal.red; public void Change () {switch (couleur) {case rouge: color = signal.Green; casser; CASE Jaune: Color = Signal.Red; casser; caser vert: color = signal.yellow; casser; }}}Utilisation 3: Ajoutez une nouvelle méthode à l'énumération
Couleur de l'énumération publique {rouge ("rouge", 1), vert ("vert", 2), vierge ("blanc", 3), yello ("jaune", 4); // Nom de chaîne privée variable de membre; Index int privé; // Construire la méthode Private Color (String Name, int index) {this.name = name; this.index = index; } // Méthode normale String statique publique getName (int index) {for (couleur c: colore.values ()) {if (c.getIndex () == index) {return c.Name; }} return null; } // get set Method public String getName () {return name; } public void setName (string name) {this.name = name; } public int getSindex () {return index; } public void setIndex (int index) {this.index = index; }}Utilisation 4: Méthodes pour écraser l'énumération
Couleur de l'énumération publique {rouge ("rouge", 1), vert ("vert", 2), vierge ("blanc", 3), yello ("jaune", 4); // Nom de chaîne privée variable de membre; Index int privé; // Construire la méthode Private Color (String Name, int index) {this.name = name; this.index = index; } // Écraser la méthode @Override public String toString () {return this.index + "_" + this.name; }}Utilisation 5: Implémentez l'interface
Comportement de l'interface publique {void print (); String getInfo (); } La couleur de l'énumération publique implémente le comportement {rouge ("rouge", 1), vert ("vert", 2), vierge ("blanc", 3), yello ("jaune", 4); // Nom de chaîne privée variable de membre; Index int privé; // Construire la méthode Private Color (String Name, int index) {this.name = name; this.index = index; } // Méthode d'interface @Override public String getInfo () {return this.name; } // Méthode d'interface @Override public void print () {System.out.println (this.index + ":" + this.name); }}Utilisation 6: Utilisez l'interface pour organiser l'énumération
Interface publique Aliments {Enum Coffee implémente la nourriture {Black_Coffee, DECAF_COFFEE, Latte, Cappuccino} Enum Dessert implémente la nourriture {fruit, gâteau, gelato}}Ce qui précède concerne cet article, j'espère qu'il sera utile à l'apprentissage de tout le monde.