Introduction détaillée aux types d'énumération en Java

Il existe une méthode de valeurs dans l'énumération qui est utilisée pour générer un tableau dans l'ordre défini par l'énumération, qui peut être utilisé pour parcourir. Nos classes d'énumération personnalisées héritent toutes de java.lang.Enum et ont les fonctions suivantes dans les exemples :

Nous pouvons également utiliser des références d'énumération statique :

En plus d'ajouter des méthodes à une énumération, qui ne peuvent pas être héritées, l'énumération peut être traitée comme une classe générale, ce qui signifie que vous pouvez ajouter des méthodes à l'énumération, et vous pouvez également définir la méthode principale dans l'énumération :


Énumérations dans les instructions switch Les énumérations jouent généralement un rôle important dans les instructions switch. Habituellement, les instructions switch ne fonctionnent que sur des valeurs entières, mais il existe un ordre intégré des entiers dans les énumérations, de sorte que l'ordre des instances peut être déterminé par une méthode obtenue. les énumérations peuvent donc être utilisées dans les instructions switch :

Le secret des valeurs() Bien que nous ayons utilisé la méthode des valeurs auparavant, si nous regardons Enum, nous ne trouvons pas la méthode des valeurs. Alors, y a-t-il d'autres méthodes cachées ? Nous pouvons le vérifier avec un simple code de réflexion :

On peut voir que la méthode des valeurs est ajoutée par le compilateur. La méthode valueOf est également ajoutée par le compilateur lors de la création de l'énumération, mais il existe également une méthode valueOf dans la classe Enum, mais cette méthode a deux paramètres, tandis que la méthode valueOf ajoutée par le compilateur n'a qu'un seul paramètre. Les énumérations sont interprétées comme finales par le compilateur, elles ne peuvent donc pas être héritées. Étant donné que la méthode des valeurs est une méthode statique ajoutée par le compilateur, si vous convertissez l'énumération en Enum, la méthode des valeurs ne sera pas disponible, mais il existe une méthode getEnumConstants dans Class, donc bien que la méthode des valeurs soit non disponible dans Enum , mais vous pouvez toujours obtenir l'instance d'énumération via l'objet Class :

Implémentation sans héritage Étant donné que les types d'énumération que nous définissons héritent tous de java.lang.Enum et que Java ne prend pas en charge l'héritage multiple, les énumérations ne sont donc pas créées par héritage, mais les énumérations peuvent être créées en héritant d'une ou plusieurs interfaces :

Sélection aléatoire Dans plusieurs de nos exemples ultérieurs, nous sélectionnerons aléatoirement des objets à partir d'instances d'énumération. Nous créons une classe publique pour implémenter ceci :


L'utilisation d'interfaces pour organiser les énumérations ne peut pas être héritée, ce qui nous cause parfois des désagréments, car parfois nous voulons augmenter le nombre d'énumérations par héritage, et parfois nous devons regrouper les énumérations. Pour ces derniers, nous pouvons définir des énumérations groupées au sein de l'interface, puis créer l'énumération en héritant de cette interface. Comme suit, nous avons différentes catégories d'aliments qui doivent être créées sous forme d'énumérations, mais nous devons définir chaque catégorie comme types. de la nourriture sont les suivantes :

Étant donné que chaque énumération est définie comme une implémentation d’une interface, chaque énumération est de type Food, comme suit :

Mais les interfaces ne peuvent pas fonctionner sur plusieurs types comme les énumérations, donc si vous avez besoin d'une énumération d'énumérations, vous pouvez encapsuler une instance de chaque type d'énumération dans une énumération :

Chaque énumération utilise l'objet Class comme paramètre de constructeur correspondant. Nous pouvons utiliser getEnumConstants à partir de ce paramètre pour obtenir l'instance d'énumération. Cette instance peut être utilisée dans la méthode randomSelection pour générer des repas aléatoires :

Voici une implémentation plus compacte :


Utiliser EnumSet au lieu des indicateurs EnumSet a été ajouté dans Java SE5 pour combiner des énumérations et des ensembles afin de remplacer les indicateurs de bits basés sur des entiers. Les indicateurs de bits sont généralement utilisés pour indiquer le changement d'un certain type d'information, mais dans le code, les bits sont exploités plutôt que des concepts significatifs, ils ne sont donc pas faciles à comprendre. EnumSet est plus rapide que les indicateurs de bits. Il utilise long en interne pour représenter un vecteur de bits, et vous pouvez ensuite utiliser un langage plus conceptuel pour représenter le changement d'un certain bit sans vous soucier de l'efficacité. Les éléments dans EnumSet doivent provenir de la même énumération. Ce qui suit définit une énumération de la position d'alarme :

Utilisez ensuite la classe EnumSet pour suivre l'état de l'alarme :

EnumSet est construit sur un type long et comporte 64 bits, alors que se passe-t-il si notre type d'énumération dépasse ce nombre ?

Nous pouvons voir que le programme fonctionne normalement, il est donc très probable qu'un type long ait été ajouté en interne pour aider à s'adapter au type d'énumération utilisant EnumMap.
EnumMap est un type spécial de Map. La valeur de sa clé ne peut être que le type dans la même énumération. Pour cette raison, EnumMap peut être implémenté en interne via un tableau, ce qui est très efficace.

Méthodes constantes spécifiques Les énumérations Java ont une fonctionnalité très intéressante, c'est-à-dire que différents comportements peuvent être définis pour chaque instance d'énumération. Pour y parvenir, nous définissons une ou plusieurs méthodes abstraites dans le cadre de l'énumération, puis définissons des comportements différents pour chacune. instance d'énumération. Une méthode de définition d'instance d'énumération :

Le code ci-dessus semble indiquer que chaque élément d'énumération est un élément différent et que tous les éléments héritent de la classe de base ConstantSpecificMethod, mais nous ne pouvons pas vraiment le comprendre de cette façon, car nous ne pouvons pas traiter les éléments d'énumération comme des types :

Prenons un autre exemple. Il existe un menu de lavage de voiture. Les clients choisissent différents services en fonction de différents menus. Vous pouvez utiliser des méthodes constantes spécifiques pour associer le menu aux services et utiliser EnumSet pour conserver les choix du client, comme suit :

Nous pouvons également remplacer les méthodes constantes spécifiques par défaut au lieu d'utiliser des méthodes abstraites héritées, comme suit :

Parfois, nous souhaitons transmettre des requêtes spécifiques dans la chaîne. Sachant qu'un objet de la chaîne peut gérer la requête peut être facilement réalisé en utilisant des méthodes constantes spécifiques. Voici un exemple de traitement des e-mails :

Le type énumération est également un type idéal pour créer une machine à états. Une machine à états peut se déplacer entre un nombre limité d'états en fonction de l'entrée, puis terminer le travail une fois qu'un certain état est atteint. sortie correspondante. Un distributeur automatique est un exemple de machine à états typique où nous définissons différentes entrées au sein d'une énumération :

VendingMachine est utilisé pour répondre à l'entrée. Tout d'abord, il classe l'entrée via l'énumération Category, puis utilise l'instruction switch :

Voici les données de test utilisées pour générer le résultat ci-dessus :

Déballage multiple Lorsqu'il s'agit d'interactions entre plusieurs types, le code risque de devenir compliqué, comme Number.plush(Number), Number.mutiply(Number), etc. Number n'est qu'une classe de base de la famille, donc lorsque vous appelez Lorsque a.plus(b), vous ne connaissez ni le type de a ni le type de b, alors comment vous assurer que l'interaction entre eux est correcte ? Java ne peut effectuer qu'un seul déballage, c'est-à-dire que si une ou plusieurs opérations sur plusieurs types inconnus sont effectuées, Java ne peut effectuer un mécanisme de liaison dynamique que sur l'un des types, ce qui ne peut pas résoudre le problème dont nous avons parlé ci-dessus. pour écrire manuellement le code de liaison dynamique.
La solution consiste à utiliser la liaison multiple. Le polymorphisme ne peut se produire que lors de l'appel d'une méthode, donc si vous avez besoin de plusieurs décompressions, vous devez appeler plusieurs méthodes. Avec le déballage multiple, vous devez disposer d'une méthode virtuelle qui appelle la méthode de chaque type à déballer. L’exemple suivant est un exemple pierre-papier-ciseaux :

Nous avons utilisé de nombreuses méthodes pour réaliser plusieurs décompressions, mais nous avons obtenu une bonne structure de code. Le plus gros problème lors de l'utilisation d'une solution d'énumération pour implémenter le code ci-dessus est que l'instance d'énumération n'est pas un type, donc l'instance d'énumération ne peut pas être utilisée comme type de paramètre. Mais nous pouvons toujours avoir d'autres moyens de contourner cet obstacle.



Étant donné que la formulation de méthodes statiques peut fournir différentes méthodes pour chaque type d'énumération, cela semble être une bonne solution pour obtenir un déballage multiple, mais nous sommes toujours confrontés au problème que l'instance d'énumération n'est pas un type, donc tout ce que nous pouvons faire est d'ajouter une instruction Switch :

Le code suivant est une méthode d'implémentation plus concise:

La classe Enuummap semble être un bon moyen d'implémenter un déballage multiple:

Nous pouvons également utiliser la fonctionnalité des instances d'énumération avec des valeurs fixes pour utiliser des données pour la méthode d'implémentation la plus simple.