Java Academy · Lektion

Enums definieren und verwenden

Deklarieren Sie enum-Typen, verwenden Sie ihre Konstanten und durchlaufen Sie sie mit values() und ordinal().

Enums definieren und verwenden ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Enums definieren und verwenden

Ein enum (Aufzählungstyp) ist eine spezielle Klasse, die eine feste Menge von Konstanten darstellt. Enums sind typsicher, gut lesbar und leistungsfähiger als statische int-Konstanten.

Ein Enum deklarieren

Verwenden Sie das Schlüsselwort enum, um eine Aufzählung zu deklarieren. Jede Konstante ist implizit public static final und eine Instanz des Enum-Typs.

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

Day today = Day.WEDNESDAY;
System.out.println(today);          // WEDNESDAY
System.out.println(today.name());   // WEDNESDAY
System.out.println(today.ordinal()); // 2 (zero-based index)

Mit values() iterieren

EnumType.values() gibt alle Konstanten in der Deklarationsreihenfolge zurück. Verwenden Sie es zum Iterieren oder zum Erstellen von Menüs.

enum Planet { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE }

for (Planet p : Planet.values()) {
    System.out.println(p.ordinal() + ": " + p);
}
// 0: MERCURY
// 1: VENUS
// 2: EARTH
// ...

// Count constants
System.out.println(Planet.values().length); // 8

valueOf() und Parsen

Enum.valueOf(name) wandelt einen String in die passende Konstante um. Wenn keine passende Konstante gefunden wird, wird IllegalArgumentException ausgelöst.

enum Status { PENDING, ACTIVE, SUSPENDED, CLOSED }

String input = "ACTIVE";
Status s = Status.valueOf(input);
System.out.println(s); // ACTIVE

try {
    Status bad = Status.valueOf("UNKNOWN");
} catch (IllegalArgumentException e) {
    System.out.println("Invalid status: UNKNOWN");
}

// Safe parse pattern
static Status safeFrom(String name) {
    try { return Status.valueOf(name.toUpperCase()); }
    catch (IllegalArgumentException e) { return Status.PENDING; }
}

Enums in switch verwenden

Enums funktionieren perfekt in switch-Anweisungen und -Ausdrücken. Moderne switch-Ausdrücke machen die Enum-Verzweigung kompakt und vollständig.

enum OrderStatus { CREATED, PROCESSING, SHIPPED, DELIVERED, CANCELLED }

OrderStatus status = OrderStatus.SHIPPED;

String message = switch (status) {
    case CREATED     -> "Order received, awaiting payment";
    case PROCESSING  -> "Payment confirmed, preparing shipment";
    case SHIPPED     -> "On the way — track your package";
    case DELIVERED   -> "Delivered! Enjoy your order";
    case CANCELLED   -> "Order cancelled";
};
System.out.println(message); // On the way — track your package

Enums mit if/else

Verwenden Sie ==, um Enum-Konstanten zu vergleichen – sie sind Singleton-Instanzen, daher funktioniert der Referenzvergleich korrekt.

enum UserRole { GUEST, MEMBER, ADMIN, SUPERADMIN }

UserRole role = UserRole.ADMIN;

if (role == UserRole.ADMIN || role == UserRole.SUPERADMIN) {
    System.out.println("Access granted to admin panel");
} else {
    System.out.println("Access denied");
}

// Enum comparison: never use .equals() for enums
// == is correct and more readable

Enums in Collections

Enums können in Standard-Collections gespeichert werden. Verwenden Sie EnumSet und EnumMap für eine leistungsfähige Enum-basierte Speicherung (wird in einer späteren Lektion behandelt).

import java.util.*;

enum Permission { READ, WRITE, DELETE, ADMIN }

Set<Permission> userPerms = new HashSet<>();
userPerms.add(Permission.READ);
userPerms.add(Permission.WRITE);

System.out.println(userPerms.contains(Permission.DELETE)); // false
System.out.println(userPerms.contains(Permission.READ));   // true

List<Permission> allPerms = Arrays.asList(Permission.values());
System.out.println(allPerms.size()); // 4

Enums implementieren Interfaces

Enums können Interfaces implementieren, sodass Sie jeder Konstante Verhalten zuweisen oder einen gemeinsamen Vertrag für alle Konstanten definieren können.

interface Describable {
    String describe();
}

enum Season implements Describable {
    SPRING, SUMMER, FALL, WINTER;

    public String describe() {
        return switch (this) {
            case SPRING -> "Mild and rainy";
            case SUMMER -> "Hot and sunny";
            case FALL   -> "Cool with falling leaves";
            case WINTER -> "Cold and snowy";
        };
    }
}

for (Season s : Season.values()) {
    System.out.println(s + ": " + s.describe());
}

Enum als Zustandsautomat

Enums eignen sich hervorragend für Zustandsautomaten. Jede Konstante stellt einen Zustand dar, und Methoden definieren gültige Übergänge.

enum TrafficLight {
    RED, YELLOW, GREEN;

    public TrafficLight next() {
        return switch (this) {
            case RED    -> GREEN;
            case GREEN  -> YELLOW;
            case YELLOW -> RED;
        };
    }
}

TrafficLight light = TrafficLight.RED;
for (int i = 0; i < 6; i++) {
    System.out.println(light);
    light = light.next();
}
// RED, GREEN, YELLOW, RED, GREEN, YELLOW

Best Practices für Enums

Beachten Sie bei der Verwendung von Enums die folgenden Best Practices:

Verwenden Sie Namen in ALL_CAPS für Konstanten (Konvention)
Bevorzugen Sie aus Gründen der Typsicherheit Enums gegenüber int- oder String-Konstanten
Verwenden Sie switch-Ausdrücke für eine vollständige Verzweigung
Fügen Sie Enums Felder und Methoden hinzu, wenn Konstanten Daten enthalten

Praktisch: HTTP-Statuscodes

Ein praxisnahes Enum zur Modellierung von HTTP-Statuskategorien mit einer Factory-Methode für den numerischen Code.

enum HttpStatus {
    OK(200), CREATED(201), BAD_REQUEST(400),
    UNAUTHORIZED(401), NOT_FOUND(404), SERVER_ERROR(500);

    public final int code;

    HttpStatus(int code) { this.code = code; }

    public static HttpStatus from(int code) {
        for (HttpStatus s : values())
            if (s.code == code) return s;
        throw new IllegalArgumentException("Unknown HTTP code: " + code);
    }

    public boolean isSuccess() { return code >= 200 && code < 300; }
}

HttpStatus s = HttpStatus.from(404);
System.out.println(s + " (" + s.code + ") success=" + s.isSuccess());
// NOT_FOUND (404) success=false

Schnelltest

Welche Ausgabe erzeugt der folgende Code?

enum Color { RED, GREEN, BLUE }
System.out.println(Color.GREEN.ordinal());

Zusammenfassung: Enums definieren und verwenden

Wichtigste Erkenntnisse:

Enums definieren eine feste Menge benannter Konstanten mit Typsicherheit
values() durchläuft alle Konstanten; ordinal() liefert den nullbasierten Index
valueOf() wandelt einen String in die passende Konstante um
Verwenden Sie zum Vergleichen von Enum-Instanzen == (nicht equals)
Enums eignen sich hervorragend in switch-Ausdrücken für eine vollständige Verzweigung
Enums können Interfaces implementieren, um jeder Konstante eigenes Verhalten zuzuweisen

Häufig gestellte Fragen

Ist die Lektion „Enums definieren und verwenden“ kostenlos?

Ja — der vollständige Text von „Enums definieren und verwenden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Enums definieren und verwenden“?

Deklarieren Sie enum-Typen, verwenden Sie ihre Konstanten und durchlaufen Sie sie mit values() und ordinal(). Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Enums definieren und verwenden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy