Les énumérations (type Enum) #

Dans ce chapitre, nous allons aborder les énumérations. Il ne s’agit pas d’une spécificité de la POO, mais d’un type de données particulier. En Java, elles permettent de décrire un ensemble fixe de valeurs constantes prédéfinies.

Voici un exemple classique d’une énumération des jours de la semaine.

1
2
3
4

public enum Day {
    Monday, Tuesday, Wednesday,
    Thursday, Friday, Saturday, Sunday
}

Voici l’équivalent en syntaxe BNF¹:

Day ::= Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday

L’énumération en Java est typesafe, contrairement aux énumérations C.

1
2
3

void print(Day d) {
  System.out.println(d);
}

1
2

print(0); // Compil. error (C/C++ ok)
print(Day.Monday); // affiche Monday

Il s’agit en fait de classes dont les valeurs sont des singletons. Il est donc possible de les comparer avec l’opérateur ==.

Day.Monday != Day.Friday // true

L’opérateur d’égalité est null-safe & type-safe

• Day.Monday == "coucou" ne compile pas
• Day.Monday == null ne compile pas non plus

Son utilisation est possible dans une instruction switch classique (cet exemple est tiré de la documentation d’Oracle):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public static void tellItLikeItIs(Day day) {
  switch (day) {
    case Monday:
      System.out.println("Mondays are bad.");
      break;
    case Friday:
      System.out.println("Fridays are better.");
      break;
    case Saturday: case Sunday:
      System.out.println("Weekends are best.");
      break;
    default:
      System.out.println("Midweek days are so-so.");
      break;
  }
}

Tout comme une expression switch (Java 14) :

1
2
3
4
5
6
7
8

public static String tellItLikeItIs(Day day) {
  System.out.println( switch (day) {
    case Monday -> "Mondays are bad.";
    case Friday -> "Fridays are better.";
    case Saturday, Sunday -> "Weekends are best.";
    default -> "Midweek days are so-so.";
  });
}

Il est également possible de définir des membres communs à chaque valeur.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public enum City {
  Lausanne("Lausanne", "lausannois"),
  Geneve("Genève", "genevois"),
  Penthalaz("Penthalaz", "cancanier"); // ; obligatoire

  private final String name;
  private final String surname;
  private City(String name, String surname) {
    this.name = name;
    this.surname = surname;
  }
  public String surname() { return this.surname; }
}

Appel de la méthode surname:

System.out.println( City.Penthalaz.surname() );

Les énumérations ne permettent pas de représenter des valeurs comportant des structures différentes comme il serait possible de le faire en Rust par exemple:

enum Status {
  Cancelled { date: Date },
  OutOfOrder { error_message: String },
  Running 
}

L’équivalent BNF se traduirait ainsi:

Status ::= Cancelled(Date) | OutOfOrder(String) | Running

Nous verrons plus tard comment réaliser ce genre d’énumérations spécifiques.