6.13 Die Spezial-Oberklasse Enum

Jedes Aufzählungsobjekt erbt von der Spezialklasse Enum. Nehmen wir erneut die Wochentage:

public enum Weekday 
{ 
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY 
}

Der Compiler übersetzt dies in eine Klasse, die etwa so aussieht:

class Weekday extends Enum 
{ 
  public static final Weekday MONDAY  = new Weekday( "MONDAY",   0 ); 
  public static final Weekday TUESDAY = new Weekday( "TUESDAY ", 1 ); 
  ... 
 
  private Weekday( String s, int i ) 
  { 
    super( s, i ); 
  }

6.13.1 Methoden auf Enum-Objekten

Von der Oberklasse Enum erbt jede Aufzählung einen geschützten parametrisierten Konstruktor, der den Namen der Konstante sowie einen assoziierten Zähler erwartet. So wird aus jedem Element der Aufzählung ein Objekt vom Basistyp Enum, das einen Namen und eine ID, die so genannte Ordinalzahl, speichert. Natürlich kann es auch nach seinem Namen und Zähler gefragt werden.

abstract class Enum<E extends Enum<E>> 
implements Comparable<E>, Serializable

• final int ordinal() Liefert die zur Konstante gehörige ID. Im Allgemeinen ist diese Ordinalzahl nicht wichtig, aber besondere Datenstrukturen wie EnumSet oder EnumMap nutzen diese eindeutige ID. Die Reihenfolge der Zahlen ist durch die Reihenfolge der Angabe gegeben.

• final String name() Liefert den Namen der Konstante. Da die Methode – wie viele andere der Klasse – final ist, lässt sich der Name nicht ändern.

• String toString() Liefert den Namen der Konstante. Die Methode ruft standardisiert name() auf, weil sie aber nicht final ist, kann sie überschrieben werden.

• final int compareTo( E o ) Da die Enum-Klasse die Schnittstelle Comparable implementiert, gibt es auch die Funktion compareTo(). Sie vergleicht anhand der Ordinalzahlen. Vergleiche sind nur innerhalb eines Enum-Typs erlaubt.

• static <T extends Enum<T>> T valueOf( Class<T> enumType, String s ) Ermöglicht das Suchen von Enum-Objekten zu einem Konstantennamen und einer Enum-Klasse. Sie liefert das enum-Objekt für die gegebene Zeichenfolge oder löst eine Illegal-ArgumentException aus, wenn dem String kein enum-Objekt zuzuordnen ist.

• final Class<E> getDeclaringClass() Liefert das Class-Objekt zu einem konkreten Enum.

static int getOrdinal( String name ) 
{ 
  try { 
    return Weekday.valueOf( name ).ordinal(); 
  } 
  catch ( IllegalArgumentException e ) { 
    return –1; 
  } 
}

System.out.println( Weekday.class.getDeclaringClass() );  // null 
System.out.println( Weekday.MONDAY.getDeclaringClass() );  
// class com.tutego.weekday.Weekday

Alle Konstanten der Klasse aufzählen

Eine besondere statische Funktion auf jeder Enum-Klasse ist values(). Sie liefert ein Feld von Enum-Objekten. Nützlich ist das für das erweiterte for, das alle Konstanten aufzählen soll. Eine Alternative mit dem gleichen Ergebnis ist die Class-Methode getEnumConstants().

Listing 6.108 WeekdayDemo.java, Ausschnitt main()

for ( Weekday day : Weekday.values() )  // oder Weekday.class.getEnumConstants() 
  System.out.println( "Name=" + day.name() );

Liefert Zeilen mit Name=MONDAY, ...

Auch toString() ist so implementiert, dass es den Namen liefert. Das Ergebnis ist also mit name() identisch:

System.out.println( Weekday.FRIDAY );                 // FRIDAY

Vergleiche mit ==

Wie die Umsetzung der Enum-Typen zeigt, wird für jede Konstante ein Objekt konstruiert, und das sind Singletons. 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 == richtig ist. Ein equals() ist nicht nötig. Die Oberklasse Enum überschreibt equals() mit der Logik wie in Object – also den Vergleich der Referenzen –, um sie final zu markieren. Die Methode clone() ist final protected und kann also weder überschrieben noch von außen aufgerufen werden. So kann es keine Kopien der Enum-Objekte geben, die die Identität gefährden könnten. Nichtsdestotrotz darf clone() aber die this-Referenz liefern.

6.13.2 enum mit eigenen Konstruktoren und Methoden

Da eine enum-Klasse mit der Klassendeklaration verwandt ist, kann sie ebenso Attribute und Methoden deklarieren:

Listing 6.109 Country.java

import java.util.Locale; 
 
public enum Country 
{ 
  GERMANY( Locale.GERMANY ), UK( Locale.UK ), CHINA( Locale.CHINA ); 
 
  private Locale country; 
 
  private Country( Locale country ) 
  { 
    this.country = country; 
  } 
 
  public String getISO3Country() 
  { 
    return country.getISO3Country(); 
  } 
}

Bei der Deklaration der Konstanten wird in runden Klammern ein Argument für den Konstruktor aufgerufen. Der speichert das zugehörige Locale-Objekt in der internen Variable country. Zusätzlich deklariert das Beispiel eine Methode getISO3Country(), die auf den Enum-Objekten aufgerufen werden kann.

System.out.println( Country.CHINA.getISO3Country() ); // CHN

Da switch auf enum erlaubt ist, können wir schreiben:

Listing 6.110 CountryEnumDemo.java, Ausschnitt

Country meinLand = Country.GERMANY; 
 
switch ( meinLand ) 
{ 
  case GERMANY: 
    System.out.println( "Aha. Ein Krauti" );         // Aha. Ein Krauti 
    System.out.println( meinLand.getISO3Country() ); // DEU 
    break; 
  default:      System.out.println( "Anderes Land" ); 
}

Enum mit überschriebenen Methoden

Würden wir für Monate eine Aufzählung Month deklarieren und eine Methode getDays() für die Anzahl Tage im Monat anbieten, dann hätten wir ein Problem mit dem Februar, weil die Anzahl der Tage bei einem Schaltjahr nicht die gleiche ist. In getDays() würden wir eine Berechnung abhängig vom Jahr benötigen. Im ersten Schritt fügen wir der Aufzählung eine Funktion getDays(int) hinzu, die die Jahreszahl akzeptiert. Die Methode ist zunächst genauso ohne Parameter implementiert wie getDays(). Java erlaubt uns aber, hinter den Konstantennamen eine Art innere anonyme Klasse zu hängen, die dann Methoden überschreiben kann.

Listing 6.111 Month.java

public enum Month 
{ 
  JAN(31), FEB(28) 
  { 
    @Override public int getDays( int y ) 
    { 
      return (y & 3) == 0 ? 29 : 28; 
    } 
  }, 
  MAR(31), APR(30), MAY(31), JUN(30), 
  JUL(31), AUG(31), SEP(30), OCT(31), NOV(30), DEC(31); 
 
  private int days; 
 
  private Month( int days ) 
  { 
    this.days = days; 
  } 
 
  public int getDays() 
  { 
    return days; 
  } 
 
  public int getDays( int year ) 
  { 
    return days; 
  } 
}

In der Angabe vom Februar überschreiben wir das Verhalten von getDays(int), sodass korrekt ausgegeben wird:

System.out.println( Month.FEB.getDays(2000) );    // 29 
System.out.println( Month.FEB.getDays(2001) );    // 28

In der Klassendatei bildet der Java-Compiler das wie folgt ab: Es gibt einen Konstruktor mit drei Parametern der Enum-Namen, der Ordinalzahl und der Zahl der Tage:

Month( String s, int i, int j ) 
{ 
  super( s, i ); 
  days = j; 
}

Für alle Monate bis auf den Februar kommt dieser Konstruktor zum Zuge. Für den Februar gibt es eine innere anonyme Klasse, die getDays() überschreibt, um das Jahr in die Berechnung mit einzubeziehen. Die übergebene 28 würde eigentlich im Konstruktor nicht mehr gebraucht werden.

public static final Month JAN = new Month( "JAN", 0, 31 ); 
public static final Month FEB = new Month( "FEB", 1, 28 ) { 
  private static final _cls1 ENUM$VALUES[]; 
  public int getDays( int y ) { return (y & 3) != 0 ? 28 : 29; } 
}; 
public static final Month MAR = new Month( "MAR", 2, 31 ); 
...

Ihr Kommentar