Mot-clé enum en Java

Le mot-clé enum en Java est utilisé pour définir un ensemble de constantes nommées. Il s'agit d'un type de données spécial qui permet à une variable d'être un ensemble de constantes prédéfinies, ce qui rend le code plus lisible et plus facile à maintenir. Les Enums sont généralement utilisés pour représenter une collection de constantes apparentées, telles que les jours de la semaine, les mois de l'année ou les états d'un processus.

Utilisation

Les Enums permettent de définir une collection de constantes de manière sûre. Ils peuvent inclure des méthodes et des champs, et mettre en œuvre des interfaces.

Syntax

enum EnumName {
    CONSTANT1, CONSTANT2, CONSTANT3;
}

• EnumName: Le nom de l'énumération.
• CONSTANT1, CONSTANT2, CONSTANT3: Les constantes définies dans l'enum.

Exemples

Exemple 1 : Enum de base

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is: " + today);
    }
}

Dans cet exemple, un enum Day est défini avec des constantes représentant les jours de la semaine. La valeur Day.MONDAY est attribuée à la variable today et le programme imprime le jour en cours.

Exemple 2 : Enum avec méthodes

enum Size {
    SMALL, MEDIUM, LARGE;

    public String getSize() {
        switch (this) {
            case SMALL: return "Small Size";
            case MEDIUM: return "Medium Size";
            case LARGE: return "Large Size";
            default: return "Unknown Size";
        }
    }
}

public class EnumWithMethodExample {
    public static void main(String[] args) {
        Size size = Size.MEDIUM;
        System.out.println("Selected size: " + size.getSize());
    }
}

Cet exemple montre un enum Size avec une méthode getSize() qui renvoie une représentation sous forme de chaîne de caractères de la taille. La variable size est affectée à Size.MEDIUM, et le programme imprime la description de la taille correspondante.

Exemple 3 : Enum avec champs et constructeur

enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double getMass() {
        return mass;
    }

    public double getRadius() {
        return radius;
    }
}

public class EnumWithFieldsExample {
    public static void main(String[] args) {
        for (Planet planet : Planet.values()) {
            System.out.printf("Planet: %s, Mass: %f, Radius: %f%n", planet, planet.getMass(), planet.getRadius());
        }
    }
}

Dans cet exemple, l'énumération Planet comporte les champs mass et radius, un constructeur pour initialiser ces champs et des méthodes d'obtention pour y accéder. Le programme parcourt toutes les constantes enum et imprime leurs détails.

Conseils et bonnes pratiques

• Utilisation pour les constantes: Utilisez les enums pour définir un ensemble fixe de constantes, ce qui améliore la lisibilité et la maintenance du code.
• Type Sécurité: Les Enums offrent une sécurité de type par rapport aux définitions de constantes traditionnelles utilisant final static.
• Énoncés sur les commutateurs: Les énumérations fonctionnent de manière transparente avec les instructions de commutation, ce qui rend le code plus propre.

  switch (size) {
      case SMALL:
          // Handle small size
          break;
      case MEDIUM:
          // Handle medium size
          break;
      case LARGE:
          // Handle large size
          break;
  }

• Mettre en œuvre des interfaces: Les Enums peuvent implémenter des interfaces, ce qui permet d'obtenir un code plus flexible et réutilisable.

  interface Describable {
      String getDescription();
  }
  
  enum Color implements Describable {
      RED, GREEN, BLUE;
  
      @Override
      public String getDescription() {
          return "Color: " + this.name();
      }
  }

• Évitez la surutilisation: Bien que les énumérations soient puissantes, évitez de les utiliser à l'excès pour de simples constantes. Utilisez-les lorsqu'il existe un ensemble clair de constantes apparentées.