Introduction détaillée de l'utilisation de enum en Java et exemples de code

Utilisation de Java enum

Utilisation une : constantes

Dans JDK1.5 Avant, nous définissions les constantes ainsi : public static final.... . Maintenant, avec les enums, nous pouvons regrouper les constantes liées dans un type d'enum, et les enums offrent plus de méthodes que les constantes.

public enum Color { 
 ROUGE, VERT, VIDE, JAUNE 
} 

Utilisation deux : switch

JDK1.6L'ancien switch ne supportait que les types int, char, enum. L'utilisation des enums rend notre code plus lisible.

enum Signal {
    VERT, JAUNE, ROUGE
  }
  public class TrafficLight {
    Signal color = Signal.RED;
    public void change() {
      switch (color) {
      case RED:
        color = Signal.GREEN;
        break;
      case YELLOW:
        color = Signal.RED;
        break;
      case GREEN:
        color = Signal.YELLOW;
        break;
      }
    }
  }

Utilisation troisième : ajouter une nouvelle méthode à l'enum

Si vous envisagez de définir vos propres méthodes, vous devez ajouter un point-virgule à la fin de la séquence d'instances enum. De plus, Java exige que les instances enum soient définies en premier.

public enum Color {
    RED("rouge", 1), GREEN("vert", 2), BLANK("blanc", 3), YELLO("jaune", 4);
    // 成员变量
    private String name;
    private int index;
    // Constructeur
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }
    // Méthode ordinaire
    public static String getName(int index) {
      for (Color c : Color.values()) {
        if (c.getIndex() == index) {
          return c.name;
        }
      }
      return null;
    }
    // get set méthodes
    public String getName() {
      return name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public int getIndex() {
      return index;
    }
    public void setIndex(int index) {
      this.index = index;
    }
  }

Utilisation quatrième : couvrir les méthodes d'enum

Voici un exemple de couverture de la méthode toString().

public class Test {
  public enum Color {
    RED("rouge", 1), GREEN("vert", 2), BLANK("blanc", 3), YELLO("jaune", 4);
    // 成员变量
    private String name;
    private int index;
    // Constructeur
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }
    // Méthode couverte
    @Override
    public String toString() {
      return this.index + "_" + this.name;
    }
  }
  public static void main(String[] args) {
    System.out.println(Color.RED.toString());
  }
}

Utilisation cinquième : implémenter l'interface

Tous les enums héritent de la classe java.lang.Enum. Comme Java ne supporte pas la surcharge multiple, les objets enums ne peuvent pas hériter d'autres classes.

public interface Behaviour {
    void print();
    String getInfo();
  }
  public enum Color implements Behaviour {
    RED("rouge", 1), GREEN("vert", 2), BLANK("blanc", 3), YELLO("jaune", 4);
    // 成员变量
    private String name;
    private int index;
    // Constructeur
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }
    // Méthode de l'interface
    @Override
    public String getInfo() {
      return this.name;
    }
    // Méthode de l'interface
    @Override
    public void print() {
      System.out.println(this.index + ":" + this.name);
    }
  }

Utilisation six : utilisation de l'interface pour organiser les enums

public interface Food {
    enum Coffee implements Food {
      BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
    }
    enum Dessert implements Food {
      FRUIT, CAKE, GELATO
    }
  }

Utilisation sept : concernant l'utilisation des collections d'enum

java.util.EnumSet et java.util.EnumMap sont deux collections d'enum. EnumSet garantit que les éléments de la collection ne sont pas redondants; dans EnumMap, la clé est de type enum, tandis que la valeur peut être de n'importe quel type. Concernant l'utilisation de ces deux collections, cela ne sera pas développé ici, vous pouvez consulter la documentation JDK.

La différence entre l'enum et la définition des constantes

Première partie : méthode de définition des constantes

Nous utilisons généralement les méthodes public final static pour définir le code suivant, en utilisant1Représente le feu rouge,3Représente le feu vert,2Représente le feu jaune.

public class Light {
    /* Feu rouge */
    public final static int RED = 1;
    /* Feu vert */
    public final static int GREEN = 3;
    /* Feu jaune */
    public final static int YELLOW = 2;
  }

Deuxième partie : méthode de définition des constantes du type enum

La méthode simple de définition du type enum est la suivante, nous ne pouvons pas définir chaque valeur du type enum. Par exemple, le code pour définir les feux rouges, verts et jaunes pourrait être le suivant :

public enum Light {
    RED, GREEN, YELLOW;
  }

Nous ne pouvons représenter que les feux rouges, verts et jaunes, mais nous ne pouvons pas exprimer les valeurs spécifiques. Ne vous inquiétez pas, puisque le type enum fournit un constructeur, nous pouvons réaliser cela à l'aide du constructeur et de la surcharge de la méthode toString.Tout d'abord, ajoutons une méthode de construction au type enum Light, puis chaque valeur du type enum est transmise aux paramètres correspondants via le constructeur, et la méthode toString est surchargée, dans laquelle les paramètres transmis par le constructeur sont retournés. Le code après transformation est le suivant :

public enum Light {
  // 
  13), YELLOW(2);
  // Définition de la variable privée
  private int nCode;
  // Constructeur, le type d'enumère ne peut être privé
  private Light(int _nCode) {
    this.nCode = _nCode;
  }
  @Override
  public String toString() {
    return String.valueOf(this.nCode);
  }
}

Troisième partie, exemple complet du code

Le code complet du type d'enumère est présenté ci-dessous :

public class LightTest {
  // 1.Définition du type d'enumère
  public enum Light {
    // 
    13), YELLOW(2);
    // Définition de la variable privée
    private int nCode;
    // Constructeur, le type d'enumère ne peut être privé
    private Light(int _nCode) {
      this.nCode = _nCode;
    }
    @Override
    public String toString() {
      return String.valueOf(this.nCode);
    }
  }
  /**
   * 
   * @param args
   */
  public static void main(String[] args) {
    // 1.Traversée des types d'enumères
    System.out.println("Démo de la traversée des types d'enumères ......");
    testTraversalEnum();
    // 2.Démo de l'utilisation de l'objet EnumMap
    System.out.println("Démo de l'utilisation et de la traversée de l'objet EnumMap.....");
    testEnumMap();
    // 3.Démo de l'utilisation d'EnumSet
    System.out.println("Démo de l'utilisation et de la traversée de l'objet EnumSet.....");
    testEnumSet();
  }
  /**
   * 
   * Démo de la traversée des types d'enumères
   */
  private static void testTraversalEnum() {
    Light[] allLight = Light.values();
    for (Light aLight : allLight) {
      System.out.println("Nom de la lampe actuelle : ", + aLight.name());
      System.out.println("Ordinal de la lampe actuelle : ", + aLight.ordinal());
      System.out.println("Lampe actuelle : ", + aLight);
    }
  }
  /**
   * 
   * Démo de l'utilisation d'EnumMap, l'utilisation d'EnumMap est comparable à celle de HashMap, mais le type de clé doit être de type枚举
   */
  private static void testEnumMap() {
    // 1.Démo de la définition de l'objet EnumMap, le constructeur de l'objet EnumMap nécessite des paramètres d'entrée, par défaut, c'est le type de la classe de la clé
    EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(
    Light.class);
    currEnumMap.put(Light.RED, "feu rouge");
    currEnumMap.put(Light.GREEN, "feu vert");
    currEnumMap.put(Light.YELLOW, "feu jaune");
    // 2. Parcourir l'objet
    for (Light aLight : Light.values()) {
      System.out.println("[key=" + aLight.name() + ",value="
      + currEnumMap.get(aLight) + ");
    }
  }
  /**
   * 
   * Démonstration de l'utilisation de l'EnumSet, l'EnumSet est une classe abstraite, obtient le contenu des types d'énumérations d'un type <BR/>
   * 
   * Il est possible d'utiliser la méthode allOf
   */
  private static void testEnumSet() {
    EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
    for (Light aLightSetElement : currEnumSet) {
      System.out.println("Les données actuelles de l'EnumSet sont : " + aLightSetElement);
    }
  }
}

Le résultat de l'exécution est le suivant :

Démonstration de la navigation d'un type d'énumération ......

Nom de la lampe actuelle : RED

Ordinal de la lampe actuelle : 0

Lampe actuelle :1

Nom de la lampe actuelle : GREEN

Ordinal de la lampe actuelle :1

Lampe actuelle :3

Nom de la lampe actuelle : YELLOW

Ordinal de la lampe actuelle :2

Lampe actuelle :2

Démonstration de l'utilisation et de la navigation de l'objet EnmuMap.....

[key=RED,value=feu rouge]

[key=GREEN,value=feu vert]

[key=YELLOW,value=feu jaune]

Démonstration de l'utilisation et de la navigation de l'objet EnmuSet.....

Les données actuelles de l'EnumSet sont :1

Les données actuelles de l'EnumSet sont :3

Les données actuelles de l'EnumSet sont :2

Quatrièmement, la différence entre les méthodes de définition des constantes habituelles et les méthodes de définition des constantes des énumérations

Le contenu suivant peut être un peu ennuyeux, mais il en vaut vraiment la peine de jeter un coup d'œil

1. Code :

public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}

Qu'y a-t-il de mal, tout le monde l'a utilisé pendant une longue période, il n'y a pas de problème.

Premièrement, ce n'est pas sécurisé au niveau du type. Vous devez vous assurer qu'il s'agit d'un int

Deuxièmement, vous devez également vous assurer que son intervalle est de 0 et1

Enfin, souvent, lorsque vous l'imprimez, vous ne voyez que 1 et 0 ,

Mais ceux qui ne voient pas le code ne savent pas de quoi il s'agit, jetez tous vos anciens constants public static final

2. Vous pouvez créer une classe enum, la considérer comme une classe ordinaire. Sauf qu'elle ne peut pas hériter d'autres classes. (Java est héréditaire en mono, il l'a déjà hérité de Enum),

Vous pouvez ajouter d'autres méthodes, en surchargeant celles de l'objet lui-même

3. Le paramètre switch() peut utiliser enum

4. La méthode values() est insérée par le compilateur dans la définition de enum static, donc, lorsque vous转型z une instance enum en Enum, values() n'est plus accessible. Solution : dans la classe, il y a une méthode getEnumConstants(), donc même si l'interface Enum n'a pas de méthode values(), nous pouvons toujours obtenir toutes les instances enum via l'objet Class

5. Il n'est pas possible de hériter de sous-classes de enum, si vous avez besoin d'extension des éléments de l'enum, créez une enum qui implémente une interface à l'intérieur d'une classe, ce qui permet de regrouper les éléments. Cela permet de regrouper les éléments de l'enum.

6. Utilisez EnumSet à la place des drapeaux. Enum nécessite que ses membres soient uniques, mais les éléments de l'enum ne peuvent pas être supprimés ou ajoutés.

7. La clé de EnumMap est enum, la valeur est n'importe quel autre objet Object.

8. Enum permet aux programmeurs d'écrire des méthodes pour des instances enum. Donc, chaque instance enum peut avoir des comportements différents.

9. Utilisation de la chaîne de responsabilité enum (Chain of Responsibility). Cela concerne le patron de conception de la chaîne de responsabilité. Résolvez un problème de plusieurs façons différentes, puis liez-les ensemble. Lorsqu'une demande arrive, itérativez à travers cette chaîne jusqu'à ce qu'un élément de solution puisse traiter la demande.

10. Utilisation de l'état machine enum.

11. Utilisation de la distribution multiple via enum.

　Merci de lire, j'espère que cela pourra aider tout le monde, merci pour le soutien à notre site !