0Pricing
Java Academy · Lektion

Enums mit Feldern und Methoden

Fügen Sie Enums Felder, Konstruktoren und Methoden hinzu, um Verhalten zu kapseln.

Enums mit Feldern und Methoden ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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 mit Feldern und Methoden

Enum-Konstanten können Daten enthalten. Fügen Sie Felder hinzu, indem Sie sie und einen Konstruktor deklarieren. Der Konstruktor ist automatisch private.

Felder in Enums deklarieren

Jede Enum-Konstante ruft beim Laden der Klasse den Konstruktor auf. Feldwerte werden einmal gesetzt und sind unveränderlich (wenn sie als final deklariert sind).

enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS  (4.869e+24, 6.0518e6),
    EARTH  (5.976e+24, 6.37814e6),
    MARS   (6.421e+23, 3.3972e6);

    private final double mass;    // kilograms
    private final double radius;  // meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double mass()   { return mass; }
    public double radius() { return radius; }
}

Methoden zu Enums hinzufügen

Enum-Typen können alle Methoden enthalten, die Sie auch in einer Klasse definieren würden, einschließlich berechneter Eigenschaften.

enum Planet {
    EARTH(5.976e+24, 6.37814e6);
    // ... constructor and fields ...
    static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }

    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

double earthWeight = 75.0;
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values())
    System.out.printf("Weight on %s: %.2f%n", p, p.surfaceWeight(mass));

Abstrakte Methoden für Enum-Konstanten

Jede Konstante kann ihre eigene Implementierung einer im Enum-Körper deklarierten abstrakten Methode bereitstellen.

enum Operation {
    PLUS  { public double apply(double x, double y) { return x + y; } },
    MINUS { public double apply(double x, double y) { return x - y; } },
    TIMES { public double apply(double x, double y) { return x * y; } },
    DIVIDE{ public double apply(double x, double y) { return x / y; } };

    public abstract double apply(double x, double y);
}

System.out.println(Operation.PLUS.apply(3, 4));   // 7.0
System.out.println(Operation.TIMES.apply(3, 4));  // 12.0

Enums mit String-Bezeichnungen

Ein gängiges Muster: Geben Sie jeder Konstante eine für Menschen lesbare Bezeichnung, die als Feld gespeichert wird.

enum UserRole {
    GUEST("Guest User"),
    MEMBER("Registered Member"),
    ADMIN("Administrator"),
    SUPERADMIN("Super Administrator");

    private final String label;

    UserRole(String label) { this.label = label; }

    public String label() { return label; }

    public static UserRole fromLabel(String lbl) {
        for (UserRole r : values())
            if (r.label.equalsIgnoreCase(lbl)) return r;
        throw new IllegalArgumentException(lbl);
    }
}

System.out.println(UserRole.ADMIN.label()); // Administrator

Enum mit mehreren Feldern

Enums können beliebig viele Felder enthalten. In diesem Beispiel speichert ein Währungs-Enum sowohl den ISO-Code als auch das Symbol.

enum Currency {
    USD("US Dollar", "$"),
    EUR("Euro", "\u20ac"),
    GBP("British Pound", "\u00a3"),
    JPY("Japanese Yen", "\u00a5");

    public final String name;
    public final String symbol;

    Currency(String name, String symbol) {
        this.name = name;
        this.symbol = symbol;
    }

    public String format(double amount) {
        return String.format("%s%.2f", symbol, amount);
    }
}

System.out.println(Currency.EUR.format(99.99)); // \u20ac99.99

toString() überschreiben

Überschreiben Sie toString() in einem Enum, um eine benutzerdefinierte String-Darstellung statt des Konstantennamens zurückzugeben.

enum HttpMethod {
    GET, POST, PUT, PATCH, DELETE;

    @Override
    public String toString() {
        return name().toUpperCase();
    }

    public boolean hasBody() {
        return this == POST || this == PUT || this == PATCH;
    }
}

HttpMethod m = HttpMethod.POST;
System.out.println(m);            // POST
System.out.println(m.hasBody());  // true
System.out.println(HttpMethod.GET.hasBody()); // false

Enum mit Validierung

Enum-Konstruktoren können ihre Argumente validieren, um ungültige Zustände zu verhindern.

enum DiscountTier {
    BRONZE(5), SILVER(10), GOLD(20), PLATINUM(30);

    public final int percentage;

    DiscountTier(int percentage) {
        if (percentage < 0 || percentage > 100)
            throw new IllegalArgumentException("Invalid: " + percentage);
        this.percentage = percentage;
    }

    public double apply(double price) {
        return price * (1 - percentage / 100.0);
    }
}

System.out.println(DiscountTier.GOLD.apply(100.0)); // 80.0

Enum-Singleton-Muster

Ein Enum mit nur einer Konstante ist die sicherste Möglichkeit, ein Singleton in Java zu implementieren – standardmäßig serialisierungssicher und threadsicher.

enum AppConfig {
    INSTANCE;

    private String dbUrl = "jdbc:postgresql://localhost/mydb";
    private int maxConnections = 20;

    public String getDbUrl() { return dbUrl; }
    public int getMaxConnections() { return maxConnections; }

    public void setDbUrl(String url) { this.dbUrl = url; }
}

// Access the singleton
AppConfig config = AppConfig.INSTANCE;
System.out.println(config.getDbUrl());

Enums in Domänenmodellen

Enums werden in Domänenmodellen häufig verwendet, um typsichere Kategorien darzustellen: Bestellstatus, Zahlungsmethode, Benachrichtigungstyp usw.

enum PaymentMethod {
    CREDIT_CARD("Credit Card", true),
    DEBIT_CARD("Debit Card", true),
    PAYPAL("PayPal", false),
    CRYPTO("Cryptocurrency", false),
    BANK_TRANSFER("Bank Transfer", false);

    public final String displayName;
    public final boolean instantCharge;

    PaymentMethod(String displayName, boolean instantCharge) {
        this.displayName = displayName;
        this.instantCharge = instantCharge;
    }
}

Enum-Feld oder berechneter Wert

Felder speichern feste Daten; Methoden berechnen dynamische Werte. Verwenden Sie Felder für konstante Daten und Methoden für abgeleitete Werte.

enum DayType {
    MONDAY(false), TUESDAY(false), WEDNESDAY(false),
    THURSDAY(false), FRIDAY(false),
    SATURDAY(true), SUNDAY(true);

    private final boolean weekend;
    DayType(boolean weekend) { this.weekend = weekend; }

    public boolean isWeekend()  { return weekend; }
    public boolean isWeekday()  { return !weekend; }

    public static long weekdayCount() {
        return java.util.Arrays.stream(values())
            .filter(DayType::isWeekday).count();
    }
}
System.out.println(DayType.weekdayCount()); // 5

Schnelltest

Worin unterscheidet sich ein Enum-Konstruktor von einem Konstruktor einer regulären Klasse?

Zusammenfassung: Enums mit Feldern und Methoden

Wichtigste Erkenntnisse:

  • Fügen Sie Felder und einen Konstruktor hinzu, um Daten pro Konstante zu speichern
  • Enum-Konstruktoren sind implizit private
  • Abstrakte Methoden ermöglichen jeder Konstante eine eigene Implementierung
  • Überschreiben Sie toString() für benutzerdefinierte Anzeigenamen
  • Enums mit nur einer Konstante sind die beste Singleton-Implementierung
  • Enums lassen sich als typsichere Kategorien nahtlos in Domänenmodelle integrieren

Häufig gestellte Fragen

Ist die Lektion „Enums mit Feldern und Methoden“ kostenlos?

Ja — der vollständige Text von „Enums mit Feldern und Methoden“ 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 mit Feldern und Methoden“?

Fügen Sie Enums Felder, Konstruktoren und Methoden hinzu, um Verhalten zu kapseln. 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 2 von 4.

Wie lange dauert die Lektion „Enums mit Feldern und Methoden“?

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

  1. Enums definieren und verwenden
  2. Enums mit Feldern und Methoden
  3. Switch-Ausdrücke mit Enums
  4. EnumSet und EnumMap
← Zurück zu Java Academy