6.4    Konstanten und Aufzählungen 

In Programmen gibt es Variablen, die sich ändern (wie zum Beispiel ein Schleifenzähler), aber auch andere, die sich beim Ablauf eines Programms nicht ändern. Dazu gehören etwa die Startzeit der Tagesschau oder die Maße einer DIN-A4-Seite. Die Werte sollten nicht wiederholt im Quellcode stehen, sondern über ihre Namen angesprochen werden. Dazu werden Variablen deklariert, denen genau der konstante Wert zugewiesen wird; die Konstanten heißen dann symbolische Konstanten.

In Java gibt es zur Deklaration von Konstanten zwei Möglichkeiten:

• Selbst definierte öffentliche statische finale Variablen.

• Aufzählungen über ein enum (die intern aber auch nur öffentliche finale statische Werte sind)

 

6.4.1    Konstanten über statische finale Variablen 

Erinnern wir uns noch einmal an die Klasse City und die statische Variable:

public class City {

 

  private static int KANDY_HERSHEY_DISTANCE = 124;

  ...

}

Die Variable kann jeder ändern, der Zugriff auf die Klasse City hat.

Statische Variablen werden auch verwendet, um symbolische Konstanten zu deklarieren. Damit die Variablen unveränderlich bleiben, gesellt sich der Modifizierer final hinzu. Dem Compiler wird auf diese Weise mitgeteilt, dass dieser Variablen nur einmal ein Wert zugewiesen werden darf. Für Variablen bedeutet dies: Es sind Konstanten; jeder erneute Schreibzugriff wäre ein Fehler. In der Regel sind die Konstanten öffentlich, aber natürlich können sie auch privat sein, wenn sie nur die Klasse etwas angehen.

public class City {

 

  private static final int KANDY_HERSHEY_DISTANCE = 124;

  ...

}

Jetzt kann die Variable KANDY_HERSHEY_DISTANCE nur noch gelesen, aber später nicht mehr modifiziert werden. Der Zugriff auf die statische finale Variable sieht genauso aus wie ein Zugriff auf andere statische Variablen.

 

6.4.2    Typunsichere Aufzählungen 

Konstanten sind eine wertvolle Möglichkeit, den Quellcode aussagekräftiger und klarer zu gestalten, was wichtig ist, denn Quellcode wird öfter gelesen als geschrieben. Oftmals finden sich Konstanten für mathematische Konstanten oder Größenbeschränkungen.

Eine besondere Form bilden Konstanten, wenn sie als Elemente von Aufzählungen verwendet werden. Aufzählungen erinnern an abgeschlossene Mengen, so wie:

• Tage der Woche (Montag, Dienstag …)

• Monate eines Jahrs (Januar, Februar …)

• Font-Stile (fett, kursiv …)

• vordefinierte Linienmuster (durchgezogen, gestrichelt …)

Die Tage der Woche und auch die Monate des Jahres werden zum Beispiel von der Klasse java. util.Calendar über öffentliche statische int-Konstanten angeboten.

int month = Calendar.JUNE;

int conception = (month + 9) % 12;

System.out.println( conception );   // 2

Soll eine Klasse CandyType zum Beispiel Konstanten für die Beschaffenheit einer Süßigkeit deklarieren, kann das so aussehen:

Listing 6.26     src/main/java/com/tutego/insel/game/c/v9/CandyType.java, Ausschnitt

public class CandyType {

  private CandyType() { }  // Privater Konstruktor

 

  public static final int OTHER     = 0;

  public static final int CARAMELS  = 1;

  public static final int CHOCOLATE = CARAMELS + 1;

  public static final int GUMMIES   = CHOCOLATE * 2;

}

Für ihre Belegungen ist es günstig, die Konstanten relativ zum Vorgänger zu wählen, um das Einfügen in der Mitte zu vereinfachen. Das sehen wir bei den Variablen CHOCOLATE und GUMMIES.

Problem mit dem Datentyp int als Konstantentyp

Einfache Konstantentypen – wie bei uns int – bringen mehrere Nachteile mit sich. Nehmen wir an, die Klasse Candy würde den Typ der Süßigkeit als Ganzzahl speichern:

Listing 6.27     src/main/java/com/tutego/insel/game/c/v9/CandyType.java, Ausschnitt

public class Candy {

  public int price;

  public int candyType;

}

Der erste Nachteil ist, dass die Konstanten nicht unbedingt von jedem angewendet werden müssen und Entwickler die Werte eventuell direkt einsetzen.

Listing 6.28     src/main/java/com/tutego/insel/game/c/v9/Application.java, Ausschnitt

Candy candy = new Candy();

candy.candyType = CandyType.CARAMELS;      // so sollte es sein

candy.candyType = 1;                       // schlecht, aber möglich

candy.candyType = Cursor.DEFAULT_CURSOR    // grausam, aber gültig

                  + GridBagConstraints.PAGE_END / Character.LETTER_NUMBER;

candy.price = CandyType.CARAMELS ^ CandyType.GUMMIES; // SCHLUCK!

Das nächste Problem ist, wenn sich später die Belegung einer Konstanten einmal ändert. Bei einer Konstanten wie Math.PI wird das nicht passieren, aber beim Süßigkeitentyp könnte das passieren, wenn später ein neues Naschwerk eingeschoben wird. Das könnte später die ganze Logik durcheinanderbringen, wenn zum Beispiel CARAMELS nicht mehr 1, sondern später 2 wird, aber compilierte Programme den Süßigkeitentyp noch mit 1 vergleichen.

Fassen wir zusammen: Konstanten sind nur Namen für Werte, und bei der Auswertung bleibt es bei dem Wert. Niemand kann verbieten, diese Werte direkt zu übermitteln. Mit Zeichenketten als Werte der Konstanten kommen wir der Lösung auch nicht näher.

Eine gute Möglichkeit, von Ganzzahlen oder Strings wegzukommen, besteht darin, Objekte einer Klasse als Konstanten einzusetzen. Hier muss nicht auf eigene Klassendeklarationen zurückgegriffen werden, sondern Java bietet ein eigenes Sprachmittel.

 

6.4.3    Aufzählungstypen: typsichere Aufzählungen mit enum 

Damit Konstanten von Aufzählungen einen eigenen Typ bekommen und nicht mehr Ganzzahlen oder Strings sind, bietet Java ein Sprachkonstrukt über das Schlüsselwort enum. Die Schreibweise für Aufzählungen erinnert ein wenig an die Deklaration von Klassen und Variablen, nur dass das Schlüsselwort enum statt class gebraucht wird und dass die Variablen automatisch statisch und öffentlich sind und kein Typ angegeben ist. Java selbst deklariert schon viele Aufzählungstypen, etwa für Wochentage, doch wir wollen für den Typ von Süßigkeiten einen Aufzählungstyp CandyType einführen:

Listing 6.29     src/main/java/com/tutego/insel/game/c/va/CandyType.java, Ausschnitt

public enum CandyType {

  CARAMELS, CHOCOLATE, GUMMIES, OTHER

}

Die Konstantennamen werden üblicherweise großgeschrieben – so wie auch statische Variablen, die als Konstanten benutzt werden, großgeschrieben werden.

Abbildung 6.11     Eine Aufzählung in UML wird über den Stereotyp ausgedrückt.

Aufzählungen nutzen

Um zu verstehen, wie sich Aufzählungstypen nutzen lassen, ist es hilfreich, zu wissen, wie der Compiler sie umsetzt. Intern erstellt der Compiler eine normale Klasse, in unserem Fall CandyType. Alle Aufzählungselemente sind statische Variablen (Konstanten) vom Typ der Aufzählung:

public class CandyType {

  public static final CandyType CARAMELS  = new CandyType( ... );

  public static final CandyType CHOCOLATE = new CandyType( ... );

  ...

}

Beim Laden der Klasse werden vier CandyType-Objekte erzeugt und die statischen Variablen CARAMELS, CHOCOLATE, GUMMIES, OTHER initialisiert. Jetzt ist es einfach, diese Aufzählungen zu nutzen, da sie wie jede andere statische Variable angesprochen werden:

CandyType amedei = CandyType.CHOCOLATE;

Hinter den Aufzählungen stehen Objekte, die sich – wie alle anderen – weiterverarbeiten lassen.

if ( amedei == CandyType.CHOCOLATE )

  System.out.println( "Uff, das ist aber teuer" );

Auch implementieren die enum-Konstanten die toString()-Methode, die den Namen der Konstanten liefert.

Aufzählungsvergleiche mit ==

Wie die Umsetzung der Aufzählungstypen zeigt, wird für jede Konstante ein Objekt konstruiert, und das sind sogenannte Singletons, also Objekte, die nur einmal erzeugt werden. Eigene neue Aufzählungsobjekte können wir nicht aufbauen, da die Klasse nur einen privaten Konstruktor deklariert. Der Zugriff auf dieses Objekt ist wie ein Zugriff auf eine statische Variable. Der Vergleich zweier Konstanten läuft somit auf den Vergleich von statischen Referenzvariablen hinaus, wofür der Vergleich mit == völlig korrekt ist. Ein equals(…) ist nicht nötig.

public static boolean isUnknownCandyType( CandyType type ) {

  return type == CandyType.OTHER;

}

enum-Konstanten in switch

enum-Konstanten sind in switch-Anweisungen möglich.[ 151 ](Das ist möglich, da sie intern über eine Ganzzahl als Identifizierer verfügen, den der Compiler für die Aufzählung einsetzt. Das ist ein ähnliches Konzept, wie es der Compiler auch bei switch auf Strings verfolgt. ) Initialisieren wir eine Variable vom Typ CandyType, und nutzen wir eine Fallunterscheidung mit der Aufzählung für einen Test auf zwei Süßigkeitstypen:

Listing 6.30     src/main/java/com/tutego/insel/game/c/va/Application.java, Ausschnitt

CandyType werther = CandyType.CARAMELS;

switch ( werther ) {

  case CARAMELS:               // nicht CandyType.CARAMELS!

  case CHOCOLATE: System.out.println( "karamellig/schokoladig" );

}

Dass case CandyType.CARAMELS nicht möglich ist, erklärt sich dadurch, dass mit switch (werther) schon der Typ CandyType über die Variable werther bestimmt ist. Es ist nicht möglich, dass der Typ der switch-Variablen vom Typ der Variablen in case abweicht.

Referenzen vom Aufzählungstyp können null sein

Dass die Aufzählungen nur Objekte sind, hat eine wichtige Konsequenz. Blicken wir zunächst auf die Variablendeklaration type vom Aufzählungstyp, die mit einer Referenz initialisiert ist:

CandyType type = CandyType.CARAMELS;

Die Variable type speichert einen Verweis auf das CandyType.CARAMELS-Objekt. Das Unschöne an Referenzvariablen ist allerdings, dass sie auch mit null belegt werden können, was so gesehen kein Element der Aufzählung ist:

CandyType type = null;

Wenn solch eine null-Referenz in einem switch landet, gibt es eine NullPointerException, da versteckt im switch ein Zugriff auf die im Enum-Objekt gespeicherte Ordinalzahl stattfindet.

Methoden, die Elemente einer Aufzählung – also Objektverweise – entgegennehmen, sollten im Allgemeinen auf null testen und eine Ausnahme auslösen, um diesen fehlerhaften Teil anzuzeigen; das kann die gegebene Hilfsmethode Objects.requireNonNull(…) übernehmen:

Listing 6.31     src/main/java/com/tutego/insel/game/c/va/Candy.java, Ausschnitt

public class Candy {

 

  private CandyType type;

 

  public void setType( CandyType type ) {

    this.type = Objects.requireNonNull( type, "CandyType can't be null" );

  }

 

  public CandyType getCandyType() {

    return type;

  }

}

Aufzählungstypen als geschachtelten Typ deklarieren *

Neue Aufzählungstypen können auch in andere Typdeklarationen hineingesetzt werden; wir sprechen von »geschachtelten« Typen. Mit anderen Worten: CandyType kann auch innerhalb einer anderen Klasse bzw. anderen Schnittstelle deklariert werden. Ist die geschachtelte Aufzählung öffentlich, kann jeder sie nutzen. Sie folgt aber den gleichen Sichtbarkeiten wie Klassen, da Aufzählungen ja nichts anderes als Klassen sind, die der Compiler generiert. Aufzählungen innerhalb von Typen sind immer implizit statisch, das Schlüsselwort static ist also nicht nötig.

public class Candy {

  public /* static */ enum CandyType {

    CARAMELS, CHOCOLATE, GUMMIES, OTHER

  }

}

Statische Importe von Aufzählungen *

Die enum-Konstanten sind statische Variablen und können auf unterschiedliche Weise angesprochen werden. Nehmen wir noch einmal CandyType in einer eigenen Compilationseinheit:

Listing 6.32     src/main/java/com/tutego/insel/game/enums/CandyType.java

package com.tutego.insel.game.enums;

 

public enum CandyType {

  CARAMELS, CHOCOLATE, GUMMIES, OTHER

}

Die Aufzählung CandyType liegt im Paket com.tutego.insel.game.enums. Um auf eine Konstante wie CARAMELS zugreifen zu können, lassen sich unterschiedliche import-Varianten einsetzen:

Tabelle 6.5     »import«-Deklarationen und Zugriffsvarianten, Top-Level enum

Nehmen wir im Paket als zweites Beispiel eine geschachtelte Aufzählung der Klasse Candy hinzu:

Listing 6.33     src/main/java/com/tutego/insel/game/enums/CandyType.java

package com.tutego.insel.game.enums;

 

public class Candy {

  public enum CandyType {

    CARAMELS, CHOCOLATE, GUMMIES, OTHER

  }

}

Tabelle 6.6     import-Deklarationen und Zugriffsvarianten, geschachtelte enum

Standardmethoden der Aufzählungstypen *

Die erzeugten Aufzählungsobjekte bekommen standardmäßig eine Reihe von zusätzlichen Eigenschaften. Sie überschreiben sinnvoll toString(), hashCode() und equals(…) aus Object und implementieren zusätzlich Serializable und Comparable,[ 152 ](Die Ordnung der Konstanten ist die Reihenfolge, in der sie geschrieben sind. ) aber nicht Cloneable, da Aufzählungsobjekte nicht geklont werden können. Die Methode toString() liefert den Namen der Konstanten, sodass CandyType.CARAMELS.toString().equals("CARAMELS") wahr ist. Zusätzlich erbt jedes Aufzählungsobjekt von der Spezialklasse Enum – Abschnitt 8.2, »Aufzählungstypen«, zeigt detaillierter die Möglichkeiten.