Enumerations – Die Aufzählungstypen von Java

In diesem Beitrag behandeln wir die Aufzählungstypen (Enumerations) in Java.

Mit der fünften Version von Java wurden Enumerations in den Kern der Programmiersprache eingebaut.

Gleichzeitig wurde das neue Schlüsselwort enum eingeführt. Mit dem neuen Schlüsselwort enum werden in Java eigene Aufzählungstypen definiert.

Die Syntax ist, wie an folgendem Beispiel zu erkennen ist, sehr einfach und intuitiv:

enum Typname {WertA, WertB, WertC, ...}

Auf die definierten Werte des Aufzählungstyps wird über Typname.WertA zugegriffen. Diese können einer Variablen vom Typ der Enumeration zugewiesen werden, etwa folgendermaßen: Typname variableX = Typname.WertA;.

In Java sind Aufzählungstypen als Klassen realisiert. Die definierten Werte sind als Objekte implementiert. Daraus ergeben sich die folgenden nützlichen Eigenschaften:

• Der Name der Werte kann mit Hilfe der toString-Methode im Klartext ausgegeben werden.
• Mit Hilfe der equals-Methode kann auf Gleichheit geprüft werden.
• Enumerations können in switch-Anweisungen verwendet werden.
• Die beiden Interfaces Comparable und Serializable sind für Aufzählungen implementiert.
• Mit Hilfe der values-Methode wird ein Array zurückgegeben, das alle Elemente der Enumeration enthält. In Verbindung mit der erweiterten for-Schleife können die Elemente sehr einfach durchlaufen werden.
• Mit EnumSet und EnumMap wurden zwei neue Collection-Klassen eingeführt, die das Arbeiten mit Enumerations-Mengen erleichtern.

In dem folgenden Quellcode-Beispiel werden wir eine Enumeration definieren und mit den Werten der erstellten Aufzählung arbeiten:

Beispielanwendung: Enumerations in Java

/*
 * Beispielanwendung: Enumerations in Java
 */

public class EnumTest
{
  // Die Enumeration wird in Java wie eine lokale Klasse behandelt
  enum Jahreszeiten {FRUEHLING, SOMMER, HERBST, WINTER}

  public static boolean isCold (Jahreszeiten j)
  {
     boolean b = false;

     switch(j)
     {
       case WINTER: 
         b = true;
         break;

       case FRUEHLING:
       case SOMMER:
       case HERBST: 
         b = false;
         break;

       default: 
         b = false;
     }

     return b;
  }

  public static void main (String[] args)
  {
    // Enumeration-Variablen
    Jahreszeiten jz1 = Jahreszeiten.FRUEHLING;
    Jahreszeiten jz2 = Jahreszeiten.SOMMER;
    Jahreszeiten jz3 = Jahreszeiten.HERBST;
    Jahreszeiten jz4 = Jahreszeiten.WINTER;

    // Ausgabe der Werte in Klartext mit toString()
    System.out.println("\n" + jz1.toString());
    System.out.println(jz2);
    System.out.println(jz3);
    System.out.println(jz4);

    // Vergleichen der Werte mittels equals()
    boolean a = jz1.equals(jz2);
    System.out.println("\n" + a);
    System.out.print(jz1);
    System.out.print(a ? " = " : " != ");
    System.out.println(jz2);

    // Übergabe an Methoden und Nutzen der switch-Anweisung
    System.out.println("\n" + isCold(jz1));
    System.out.println(isCold(jz2));
    System.out.println(isCold(jz3));
    System.out.println(isCold(jz4) + "\n");

    // Einfaches Auslesen der Aufzählungswerte mit erweiterter for-Schleife
    for(Jahreszeiten j : Jahreszeiten.values())
    {
       System.out.print(j + " ");
    }

    System.out.println();
  } 
}

In Zeile 8 wird ein Aufzählungstyp mit der Bezeichnung Jahreszeiten definiert. Anschließend werden für ihn die Werte FRUEHLING, SOMMER, HERBST und WINTER erstellt.

In der main-Methode werden in den Zeilen 36 bis 39 Variablen vom Typ Jahreszeiten deklariert und mit den Werten der Enumeration initialisiert. Anschließend wird der Inhalt der Variablen auf der Kommandozeile ausgegeben. Die Ausgabe der Werte im Klartext erfolgt mit Hilfe der toString-Methode. Zur Vereinfachung kann aber auch die Variable direkt angegeben werden.

In Zeile 48 wird mit Hilfe der equals-Methode verglichen, ob die Werte der Variablen jz1 und jz2 übereinstimmen. Das Ergebnis der Abfrage wird in der boolean-Variable a gespeichert und mit Hilfe des Fragezeichen-Operators auf der Konsole ausgegeben.

In den Zeilen 55 bis 58 wird die isCold-Methode aufgerufen und ihr als Argument eine Variable vom Typ Jahreszeiten übergeben. Die isCold-Methode verwendet die switch-Anweisung von Java und soll verdeutlichen wie Enumerations bei switch-Anweisungen eingesetzt werden.

Am Ende der main-Methode, in den Zeilen 61 bis 64, werden mit Hilfe der erweiterten for-Schleife die Aufzählungswerte der Enumeration ausgelesen und auf der Kommandozeile ausgegeben. Dafür wird auf die standardmäßig implementierte values-Methode zurückgegriffen, die ein Array zurückgibt, das alle Elemente der Enumeration enthält.

Starten wir nun die Beispielanwendung. In der unteren Abbildung ist die Kommandozeilenausgabe des Programms dargestellt:

Was macht Enumerations so besonders?

Die Aufzählungsklasse (Enumeration) erweitert die Klasse java.lang.Enum und erbt dadurch eine Reihe sehr nützlicher Funktionen, wie:

• Das Singleton-Verhalten ist automatisch implementiert, durch korrekt umgesetzte Serialisierung.
• Automatisch generierte, menschenlesbare toString()-Methode für Enum-Werte, ohne dass Sie Ihre Enum-Namen duplizieren müssen.
• Spezialmethode name() und ordinal() für bestimmte Aufgaben.
• Verwendbar in den hochleistungsfähigen bitset-basierten EnumSet– und EnumMap-Klassen.

Enumerations werden von der Sprache Java speziell behandelt:

• Enumerations verwenden eine spezielle Syntax, die die Erzeugung von Instanzen vereinfacht, ohne Dutzende von public static final Felder schreiben zu müssen.
• Enumerations können in switch-Anweisungen verwendet werden.
• Enumerations können nicht außerhalb der Aufzählungsliste instanziiert werden, außer mit Hilfe von Reflection.
• Enumerations können nicht außerhalb der Aufzählungsliste erweitert werden.

Java kompiliert automatisch zusätzliche Funktionen in Enumerations:

• public static (Enum)[] values();
• public static (Enum) valueOf(java.lang.String);
• private static final (Enum)[] $VALUES; (values() liefert einen geklonten Wert der this-Instanz zurück)

Die meisten der oben aufgeführten Besonderheiten können auch mit einer entsprechend gestalteten Klasse emuliert werden, aber Enumerations machen es wirklich einfach, eine Klasse mit diesen besonders wünschenswerten Eigenschaften zu erstellen.

Die Aufzählungsklasse (Enumeration) bei ihrer Deklaration erweitern

Da in Java Aufzählungstypen als Klassen realisiert sind, ist es möglich die Aufzählungsklasse direkt bei ihrer Deklaration zu erweitern. Die Aufzählungstypen (Enumerations) werden vom Java-Compiler in lokale Klassen übersetzt und die Aufzählungswerte sind Instanzen dieser Klasse (Objekte vom Typ der Aufzählungsklasse).

Die Aufzählungsklasse kann um Membervariablen und Methoden erweitert werden, dadurch erhalten sie und ihre Aufzählungswerte zusätzliche Funktionalität.

In dem folgenden Quellcode-Beispiel werden wir eine Enumeration-Klasse um zusätzliche Eigenschaften und Funktionen erweitern:

Beispielanwendung: Enumerations erweitern in Java

/*
 * Beispielanwendung: Enumerations erweitern in Java
 */

enum Jahreszeiten
{
  FRUEHLING(true),
  SOMMER(true, 2014),
  HERBST(false),
  WINTER(false);

  private final boolean sommerzeit;
  public int normaleVariable = 0;

  Jahreszeiten(boolean a)
  {
    this.sommerzeit = a;
  }

  Jahreszeiten(boolean a, int b)
  {
    this.sommerzeit = a;
    this.normaleVariable = b;
  }

  public boolean isSommerzeit()
  {
    return this.sommerzeit;
  }
}


public class EnumTest2
{
  public static void main (String[] args)
  {
    // Enumeration-Variablen
    Jahreszeiten jz1 = Jahreszeiten.FRUEHLING;
    Jahreszeiten jz2 = Jahreszeiten.SOMMER;
    Jahreszeiten jz3 = Jahreszeiten.HERBST;
    Jahreszeiten jz4 = Jahreszeiten.WINTER;

    // Ausgabe der Werte in Klartext mit toString()
    System.out.println("\n" + jz1.toString());
    System.out.println(jz2 + " - Sommerzeit = " + jz2.isSommerzeit() + " - " + jz2.normaleVariable);
    System.out.println(jz3 + " - Sommerzeit = " + jz3.isSommerzeit());
    System.out.println(jz4 + "\n");


    // Einfaches Auslesen der Aufzählungswerte mit erweiterter for-Schleife
    for(Jahreszeiten j : Jahreszeiten.values())
    {
       System.out.println(j + " Sommerzeit = " + j.isSommerzeit());
    }
  } 
}

In den Zeilen 5 bis 30 wird die Aufzählungsklasse Jahreszeiten definiert. Die Klasse enthält die Konstante sommerzeit vom Typ boolean und die veränderbare Membervariable normaleVariable vom Typ int.

Zu Beginn werden in den Zeilen 7 bis 10 die vier Aufzählungswerte initialisiert. Dabei werden mit Hilfe der beiden Konstruktoren die jeweiligen Startwerte für die Membervariablen zugewiesen. Die Konstante sommerzeit kann danach nicht mehr verändert werden, da sie als final deklariert ist.

Die beiden Konstruktoren Jahreszeiten(boolean a) und Jahreszeiten(boolean a, int b) sind weiter unten im Quelltext in den Zeilen 15 bis 24 definiert. Sie weisen der Konstanten sommerzeit und der Instanzvariable normaleVariable ihre Initialisierungswerte zu.

Am Ende der Aufzählungsklasse Jahreszeiten wird die isSommerzeit-Methode definiert. Die Methode ist innerhalb der Aufzählungsklasse implementiert und kann somit ohne zusätzliche Parameter direkt auf den Membervariablen operieren.

In den Zeilen 33 bis 56 wird die Testklasse EnumTest2 definiert, welche die main-Methode enthält. In der main-Methode werden in den Zeilen 38 bis 41 Variablen vom Typ Jahreszeiten deklariert und mit den Werten der Enumeration initialisiert. Anschließend wird der Inhalt der Variablen auf der Kommandozeile ausgegeben. Über die Jahreszeiten-Objekte kann die isSommerzeit-Methode aufgerufen und der Inhalt der Instanzvariable normaleVariable abgefragt werden, siehe Zeile 45.

Am Ende der main-Methode, in den Zeilen 51 bis 54, werden mit Hilfe der erweiterten for-Schleife die Aufzählungswerte der Enumeration ausgelesen und zusammen mit dem Rückgabewert der isSommerzeit-Methode auf der Kommandozeile ausgegeben. Dafür wird auf die values-Methode zurückgegriffen, die ein Array zurückgibt, das alle Elemente der Enumeration enthält.

Starten wir nun die Beispielanwendung. In der unteren Abbildung ist die Kommandozeilenausgabe des Programms dargestellt:

Durch Erweiterung der Aufzählungsklasse wurden die Aufzählungswerte mit zusätzlicher Intelligenz ausgestattet. Sie kennen nun nicht nur ihren eigenen Namen (FRUEHLING, SOMMER, HERBST und WINTER), sondern auch ob gerade Sommerzeit ist. Sie können mit Hilfe der isSommerzeit-Methode diese Information sogar ausgeben.

Dies alles ist möglich, da ein Aufzählungstyp in Java wie eine gewöhnliche Klasse behandelt wird, die weiter ausgebaut werden kann. Die Quellcode-Beispiele in diesem Beitrag sollen zeigen, wie Enumerations in Java verwendet werden. Wie viel Funktionalität man in einer Enumeration implementieren sollte, muss sinnvoll abgewogen werden.

Mit folgendem Link gelangt ihr zurück zum Java Programmier Kurs.

---