Java Enum est essentiellement des classes héritées de java.lang.enum. Chaque valeur d'énumération est une instance finale statique de la classe et est initialisée lorsque la classe est chargée. 1. L'énumération prend en charge l'ajout de champs, de méthodes de constructeur, de méthodes ordinaires et de méthodes abstraites pour leur permettre de transporter des données et d'encapsuler le comportement; 2. Chaque instance d'énumération implique deux champs, nom et ordinal, représentant respectivement le nom et l'ordre de déclaration. La valeur ordinale est déterminée par l'ordonnance de déclaration et n'est pas recommandée pour le jugement commercial; 3. Les énumérations reposent sur les valeurs ordinales dans le commutateur, la modification de l'ordre de déclaration affectera la logique; 4. L'énumération fournit des méthodes VALEUR () et Value Of () pour obtenir toutes les instances et trouver des instances basées sur les noms; 5. L'énumération peut implémenter les interfaces ou définir des méthodes abstraites, et différentes valeurs d'énumération peuvent réaliser différents comportements, qui conviennent aux modèles de politique et à d'autres scénarios. Comprendre ces mécanismes peut aider à écrire du code plus clair et plus efficace.

Le type Enum (Enum) de Java semble simple, mais l'implémentation interne est en fait très intéressante. Ce n'est pas un simple ensemble de constantes, mais une structure de classe complète avec un ensemble de mécanismes derrière lui pour assurer sa sécurité et sa facilité d'utilisation.

L'énumération est essentiellement une classe

Lorsque vous écrivez une enum, le compilateur Java générera automatiquement une classe héritée à partir de java.lang.Enum pour vous. Par exemple, vous avez écrit:

 Enum Couleur {rouge, vert, bleu}

Après la compilation, il deviendra en fait une classe comme ceci:

 La couleur de classe finale étend Enum <Olor> {...}

Chaque valeur d'énumération (telle que RED , GREEN ) sera définie comme une instance finale statique de cette classe et est initialisée lorsque la classe est chargée. Ces instances sont des singletons et ne peuvent pas être copiées ou modifiées, c'est pourquoi nous disons que les énumériques sont en file d'attente.

De plus, comme il s'agit d'une classe, vous pouvez ajouter des champs, des constructeurs, des méthodes normales et même des méthodes abstraites à l'énumération. Par exemple:

 Enum Couleur {
    Rouge (255, 0, 0),
    Vert (0, 255, 0);

    Final privé Int R, G, B;

    Couleur (int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    public String toString () {
        return string.format ("rgb (% d,% d,% d)", r, g, b);
    }
}

De cette fa?on, l'énumération peut transporter plus d'informations et encapsuler le comportement.

La structure de données sous-jacente de l'énumération

En plus d'enregistrer les données que vous définissez vous-même, chaque instance d'énumération aura deux champs implicites:

• name : le nom de la constante d'énumération, le type de cha?ne.
• ordinal : l'ordre des constantes de dénombrement, incréments de 0.

Ces deux champs sont accessibles via name() et ordinal() . Ils sont définis dans l' Enum de la classe parent et toutes les énumérations sont détenues par défaut.

Par exemple, dans l'exemple ci-dessus:

• Color.RED.name() renvoie "RED"
• Color.RED.ordinal() Renvoie 0

Il convient de noter que bien que ordinal() semble utile, dans le développement réel, d'essayer d'éviter de compter directement sur lui pour jugement commercial, car il est fortement lié à l'ordre des déclarations d'énumération. Une fois que la commande change, la logique peut être incorrecte.

Compatibilité de l'énumération avec le commutateur

Java prend en charge l'utilisation de types d'énumération dans les instructions switch , qui est en fait du sucre syntaxique, et la couche sous-jacente est toujours utilisée pour porter des jugements via ordinal() .

Par exemple:

 Couleur C = Color.Red;
commutateur (c) {
    case rouge: System.out.println ("rouge"); casser;
    Case vert: System.out.println ("vert"); casser;
}

Sera compilé à quelque chose comme:

 commutateur (c.oralal ()) {
    Cas 0: ... 
    Cas 1: ...
}

Donc, si vous modifiez l'ordre de Déclaration des énumérations, cela affectera le comportement du switch . Cela signifie également encore une fois, ne reposez pas trop sur ordinal() .

Quelques caractéristiques supplémentaires de l'énumération

L'énumération Java a également des fonctions cachées, telles que:

• Fournit automatiquement values() : renvoie un tableau de toutes les valeurs d'énumération. Cette méthode est générée par le compilateur.
• Fournir valueOf(String name) Méthode: La valeur d'énumération correspondante peut être obtenue en fonction du nom.
• Les interfaces peuvent être implémentées: permet à différentes instances d'énumération d'avoir des comportements différents (tels que les modèles de stratégie).
• Les énumérations peuvent avoir des méthodes abstraites: chaque valeur d'énumération doit implémenter cette méthode.

Par exemple, le code suivant montre comment permettre à l'énumération d'implémenter les interfaces:

 Animal d'interface {
    vide speak ();
}

Enum dog implémente animal {
    Barker {
        public void Speak () {System.out.println ("woof!"); }
    };
}

Cette flexibilité rend les énumérations plus que de simples ?constantes? en Java, mais plus comme une machine d'état légère ou un conteneur de politique.

Fondamentalement, c'est tout. Comprendre le mécanisme interne de l'énumération peut aider à écrire du code plus clair et plus efficace et à éviter certains pièges courants.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!