Pourquoi Java utilise-t-il des énumérations ?

Récemment, j'ai découvert qu'il existe de nombreuses façons d'utiliser l'énumération int dans le code de l'entreprise, et j'ai également vu quelques façons d'utiliser enum pour l'énumération. J'étais très curieux à ce sujet, j'ai mené des recherches, puis j'ai écrit cet article pour résumer pourquoi nous devrions utiliser enum.

Pourquoi Java utilise-t-il des énumérations ?

Supposons maintenant qu'il existe deux types de commandes : la commande avec réservation et la commande sans réservation.

Exigence 1 : La méthode submitOrder effectue différents traitements selon les différents types de commandes.

Exigence 2 : Définir le type de commande sur un objet : OrderResult.

Ce qui suit est implémenté en utilisant deux méthodes d'énumération.

int énumération

class IntEnumExample{
private static final PRE_ORDER = 1;
private static final NOT_PRE_ORDER = 2;
public void submitOrder(int orderType, OrderResult orderResult){
    orderResult.setType(orderType);
    if(orderType == PRE_ORDER){
        do something to process preOrder
    }else if(orderType == NOT_PRE_ORDER){
        do something to process other order
    }
}
public static void main(String [] args){
    IntEnumExample example = new IntEnumExample();
    //passing wrong type to the method, however, no compile error and runtime exception here, the bug is hard to be discerned.
    example.submitOrder(3, orderResult);
}
}

Comme vous pouvez le voir dans l'exemple ci-dessus, l'utilisation de l'énumération int présente plusieurs inconvénients :

1. L'énumération int n'effectue pas de vérification de type et toute valeur int peut être transmise à la méthode submitOrder ci-dessus

2. La lisibilité du code est faible S'il n'y a pas de documentation ou de code source, la signification du code est faible. la valeur transmise à submitOrder n’est pas connue.

Non seulement cela, tout comme le problème que j'ai trouvé dans le code de numérisation du sonar dans mon précédent projet de modification, de nombreuses personnes n'ont pas défini la valeur int comme statique finale lors de l'utilisation de l'énumération int comme dans l'exemple ci-dessus. Si vous oubliez de définir une variable comme finale, la valeur de l'énumération int peut être modifiée. Si vous oubliez de définir une variable comme statique, il peut arriver que la valeur int n'ait pas été initialisée lors de son utilisation.

Bref, ça va provoquer des bugs.

Voyons comment faire la même chose en utilisant enum.

class IntEnumExample{
 private enum ORDER_TYPE {
        NOT_PRE_ORDER(1),PRE_ORDER(2);
        private final int value;
        private ORDER_TYPE(int value){
            this.value = value;
        }
    }
public void submitOrder(ORDER_TYPE orderType, OrderResult orderResult){
    orderResult.setType(orderType);
    if(orderType == ORDER_TYPE.PRE_ORDER){
        do something to process preOrder
    }else if(orderType == ORDER_TYPE.NOT_PRE_ORDER){
        do something to process other order
    }
}
public static void main(String [] args){
    IntEnumExample example = new IntEnumExample();
    //compiler will complain error here, if argument is not the type in the enum.
    example.submitOrder(ORDER_TYPE.PRE_ORDER, orderResult);
}
}

Comme vous pouvez le voir dans le code ci-dessus, enum résout avec élégance le problème de l'exemple précédent.

1. Le compilateur effectuera une vérification de type sur enum Si le type ne correspond pas, le compilateur signalera directement une erreur.

2. Par rapport à la méthode de transmission directe des valeurs int à partir des types d'énumération int, la façon dont enum transmet les objets de type enum rend le code plus lisible et le type d'énumération transmis est clair en un coup d'œil.

3. Les objets du type enum eux-mêmes sont statiques finaux.

Remarque importante :

Il convient également de mentionner que si vous souhaitez parfois attribuer une valeur int à chaque type d'énumération, vous devez utiliser enum dans l'exemple défini ci-dessus chemin.

private enum ORDER_TYPE {
       NOT_PRE_ORDER(1),PRE_ORDER(2);
       private final int value;
       private ORDER_TYPE(int value){
           this.value = value;
       }
   }

enum est essentiellement une classe, donc la méthode ORDER_TYPE(int value) est le constructeur de ce type d'énumération. Par conséquent, chaque type d'énumération doit transmettre la valeur correspondante au constructeur lors de l'initialisation, par exemple : PRE_ORDER. (2).

Dans ce cas, si vous souhaitez obtenir la valeur int correspondant au type d'énumération, vous pouvez l'obtenir via ORDER_TYPE.PRE_ORDER.value.

L'utilisation d'enum est mentionnée séparément car certaines personnes peuvent utiliser directement la méthode ordinal() dans enum pour réaliser directement l'association entre le type enum et le type int. La méthode ordinal() renvoie le numéro ordinal du type enum lorsqu'il a été défini. Par exemple, ORDER_TYPE.PRE_ORDER.value.ordinal() renvoie une valeur de 0. Par conséquent, il semble que l'obtention de la valeur int correspondant au type d'énumération puisse également être obtenue via ORDER_TYPE.PRE_ORDER.value.ordinal()+1.

N'utilisez pas la méthode ordinal() ! N'utilisez pas la méthode ordinal() ! N'utilisez pas la méthode ordinal() ! Dire des choses importantes trois fois, pourquoi ?

Les nombres ordinaux sont très peu fiables et peuvent être modifiés. Supposons qu'un jour la définition de ORDER_TYPE change et que plusieurs types doivent être ajoutés, ou l'ordre dans lequel NOT_PRE_ORDER et PRE_ORDER sont accidentellement modifiés, comme :

private enum ORDER_TYPE {
       PRE_ORDER,NOT_PRE_ORDER;
   }

Cela provoquera des bugs sérieux, difficiles à trouver. Il n'y aura aucune erreur lors de la compilation ou de l'exécution.

Alors, ne vous fiez pas à la méthode ordianl().

Recommandations d'apprentissage associées : Tutoriel de base Java

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!