Wie funktionieren Enums in Java?

Question

Accepted Answer

Ein **enum** definiert einen Typ mit einer **festen Menge benannter Konstanten**. Java Enums sind viel leistungsstarker als einfache Konstantenlisten in anderen Sprachen — sie sind vollständige Klassen, die Felder, Konstruktoren und Methoden haben können.

## Grundlegendes Enum

```java
public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Day today = Day.MONDAY;

// works great in switch
switch (today) {
    case MONDAY -> System.out.println("start of week");
    case SATURDAY, SUNDAY -> System.out.println("weekend");
    default -> System.out.println("weekday");
}
```

Enums bieten **Typsicherheit** — `Day today = Day.MONDAY` kann nur gültige `Day`-Werte enthalten, im Gegensatz zur Verwendung beliebiger Ganzzahlen oder Strings als Konstanten (die ungültige Werte und Tippfehler ermöglichen).

## Integrierte Enum-Methoden

```java
Day.MONDAY.name();        // "MONDAY"
Day.MONDAY.ordinal();     // 0 — position in the declaration
Day.values();             // array of all constants (iterate them)
Day.valueOf("FRIDAY");    // get a constant by name
for (Day d : Day.values()) { ... }   // iterate all values
```

## Enums mit Feldern, Konstruktoren und Methoden (der leistungsstarke Teil)

```java
public enum Planet {
    MERCURY(3.3e23, 2.4e6),    // each constant calls the constructor with arguments
    EARTH(5.97e24, 6.37e6),
    JUPITER(1.9e27, 7.1e7);

private final double mass;       // enums can have FIELDS
    private final double radius;

Planet(double mass, double radius) {   // constructor (implicitly private)
        this.mass = mass;
        this.radius = radius;
    }
    public double surfaceGravity() {        // and METHODS
        return 6.67e-11 * mass / (radius * radius);
    }
}

Planet.EARTH.surfaceGravity();   // compute using EARTH's data
```

Jede Enum-Konstante ist eine Instanz, die über den Konstruktor konfiguriert wird — sodass Sie Daten und Verhalten mit jeder Konstante verknüpfen können. Dies ist einzigartig und leistungsstark im Vergleich zu Enums in den meisten Sprachen.

## Enums können Interfaces implementieren und pro-Konstanten-Verhalten haben

```java
public enum Operation {
    PLUS { public int apply(int a, int b) { return a + b; } },
    TIMES { public int apply(int a, int b) { return a * b; } };
    public abstract int apply(int a, int b);   // each constant implements it differently
}
Operation.PLUS.apply(2, 3);   // 5
```

## Enums sind ideale Singletons

```java
public enum Config { INSTANCE; /* fields/methods */ }
// enum singletons are thread-safe and serialization-safe by design
```

## Warum es wichtig ist

Java Enums sind eine robuste und typsichere Möglichkeit, feste Mengen verwandter Konstanten (Zustände, Tage, Rollen, Operationen) darzustellen — weit überlegen der fehleranfälligen Alternative von `int`/`String`-Konstanten, die ungültige Werte ermöglichen und keine Typprüfung bieten.

Ihre einzigartige Stärke — Felder, Konstruktoren, Methoden, Interface-Implementierung und pro-Konstanten-Verhalten — ermöglicht es Ihnen, Daten und Logik mit jeder Konstante zu verknüpfen und Domänenkonzepte elegant zu modellieren (z. B. Planeten mit Masse/Gravitation, Operationen mit ihrer Mathematik).

Sie bieten auch das sicherste Singleton-Idiom.

Enums über einfache Konstantenlisten hinaus zu verstehen — als vollständige Klassen mit Zustand und Verhalten — ermöglicht sauberere, sicherere Domänenmodellierung und ist eine häufig unterbewertete, aber wertvolle Java-Funktion sowie ein häufiges Interviewthema.