PricingLoginStart free
Java Academy · Lektion

Enums mit Feldern und Methoden

Enums um Verhalten erweitern

Lektion 1 von 413 Schritte

Enums mit Feldern und Methoden 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 sind vollständige Klassen

Ein Java-enum ist weit mehr als eine Liste von Konstanten. Es ist eine echte Klasse, deren Instanzen die Konstanten sind.

Das bedeutet, dass Enums wie jede andere Klasse Felder, Konstruktoren und Methoden besitzen können.

public class Main {
    enum Direction { NORTH, SOUTH, EAST, WEST }
    public static void main(String[] args) {
        Direction d = Direction.NORTH;
        System.out.println(d + " is a " + d.getClass().getSuperclass().getSimpleName());
    }
}

Ein Feld hinzufügen

Sie können jeder Konstante Daten zuordnen. Deklarieren Sie ein final-Feld und einen Konstruktor und übergeben Sie anschließend nach jeder Konstante in Klammern die entsprechenden Werte.

public class Main {
    enum Planet {
        EARTH(9.81), MARS(3.71), JUPITER(24.79);
        private final double gravity;
        Planet(double gravity) { this.gravity = gravity; }
        double gravity() { return gravity; }
    }
    public static void main(String[] args) {
        System.out.println("Mars gravity: " + Planet.MARS.gravity());
    }
}

Der Enum-Konstruktor ist private

Enum-Konstruktoren sind implizit private. Sie können für ein Enum kein new aufrufen; die JVM erstellt die Konstanten einmalig beim Laden der Klasse.

Dadurch wird eine feste, endliche Menge von Instanzen garantiert.

public class Main {
    enum Coin {
        PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
        private final int cents;
        Coin(int cents) { this.cents = cents; }
        int cents() { return cents; }
    }
    public static void main(String[] args) {
        int total = Coin.QUARTER.cents() + Coin.DIME.cents();
        System.out.println("Total cents: " + total);
    }
}

Mehrere Felder

Eine Konstante kann mehrere Datenwerte enthalten. Hier speichert jeder Planet sowohl seine Masse als auch seinen Radius.

public class Main {
    enum Planet {
        EARTH(5.976e24, 6.37814e6),
        MARS(6.421e23, 3.3972e6);
        private final double mass, radius;
        Planet(double mass, double radius) { this.mass = mass; this.radius = radius; }
        double surfaceGravity() {
            final double G = 6.67300E-11;
            return G * mass / (radius * radius);
        }
    }
    public static void main(String[] args) {
        System.out.printf("Earth g = %.2f%n", Planet.EARTH.surfaceGravity());
    }
}

Instanzmethoden

Enum-Methoden können Ergebnisse aus den eigenen Feldern der Konstante berechnen, genau wie normale Instanzmethoden.

public class Main {
    enum Size {
        SMALL(8), MEDIUM(12), LARGE(16);
        private final int ounces;
        Size(int ounces) { this.ounces = ounces; }
        int ounces() { return ounces; }
        double liters() { return ounces * 0.0295735; }
    }
    public static void main(String[] args) {
        System.out.printf("Large = %.2f L%n", Size.LARGE.liters());
    }
}

Integrierter Name und Ordinalwert

Jedes Enum erhält name() (den exakten Bezeichner) und ordinal() (seine nullbasierte Position).

Speichern Sie Ihre eigenen Daten, statt sich auf ordinal() zu verlassen, da dies beim Umordnen der Konstanten zu Fehlern führt.

public class Main {
    enum Day { MON, TUE, WED }
    public static void main(String[] args) {
        for (Day d : Day.values()) {
            System.out.println(d.name() + " -> ordinal " + d.ordinal());
        }
    }
}

values und valueOf

Der Compiler generiert zwei statische Hilfsmethoden:

  • values() gibt ein Array mit allen Konstanten zurück.
  • valueOf(String) sucht anhand des Namens nach einer Konstante und wirft eine Exception, wenn sie nicht gefunden wird.
public class Main {
    enum Status { ACTIVE, PAUSED, CLOSED }
    public static void main(String[] args) {
        System.out.println("count: " + Status.values().length);
        Status s = Status.valueOf("PAUSED");
        System.out.println("parsed: " + s);
    }
}

toString überschreiben

Sie können toString() überschreiben, um leserlichere Bezeichnungen bereitzustellen und den Konstantennamen im Code beizubehalten.

public class Main {
    enum Priority {
        LOW, MEDIUM, HIGH;
        @Override public String toString() {
            return name().charAt(0) + name().substring(1).toLowerCase();
        }
    }
    public static void main(String[] args) {
        for (Priority p : Priority.values()) System.out.println(p);
    }
}

Enums in switch

Enums lassen sich problemlos in switch verwenden. Mit modernen switch-Ausdrücken erhalten Sie Vollständigkeitsprüfungen und kein Fall-through.

public class Main {
    enum Traffic { RED, YELLOW, GREEN }
    static String action(Traffic t) {
        return switch (t) {
            case RED -> "Stop";
            case YELLOW -> "Slow down";
            case GREEN -> "Go";
        };
    }
    public static void main(String[] args) {
        System.out.println(action(Traffic.GREEN));
    }
}

Statische Lookup-Maps

Eine häufige Vorgehensweise ist eine statische Map, die von einem Feld zurück auf die Konstante verweist und einmal in einem statischen Initialisierer aufgebaut wird.

import java.util.HashMap;
import java.util.Map;

public class Main {
    enum Op {
        PLUS("+"), MINUS("-");
        private final String symbol;
        Op(String symbol) { this.symbol = symbol; }
        private static final Map<String, Op> BY_SYMBOL = new HashMap<>();
        static { for (Op o : values()) BY_SYMBOL.put(o.symbol, o); }
        static Op fromSymbol(String s) { return BY_SYMBOL.get(s); }
    }
    public static void main(String[] args) {
        System.out.println(Op.fromSymbol("-"));
    }
}

Enums implementieren Interfaces

Ein Enum kann ein Interface implementieren, sodass Konstanten in allgemeinem Code eingesetzt werden können.

public class Main {
    interface Describable { String describe(); }
    enum Animal implements Describable {
        DOG, CAT;
        public String describe() { return "A " + name().toLowerCase(); }
    }
    public static void main(String[] args) {
        Describable d = Animal.DOG;
        System.out.println(d.describe());
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von Enum-Feldern.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben gelernt, dass Enums vollständige Klassen sind:

  • Konstanten können Felder enthalten, die über einen privaten Konstruktor gesetzt werden.
  • Enums können Instanzmethoden enthalten und toString() überschreiben.
  • values() und valueOf() werden für Sie generiert.
  • Enums können Interfaces implementieren; verwenden Sie bevorzugt Felder statt ordinal().

Als Nächstes geht es um Verhalten pro Konstante mit abstrakten Methoden.

public class Main {
    enum Greeting { HELLO; String text() { return "Hi"; } }
    public static void main(String[] args) {
        System.out.println("Enum fields recap: " + Greeting.HELLO.text());
    }
}
Kostenlos starten

Lerne Java mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
104
Lektionen
374
Kostenlos lernenDen vollständigen Kurs ansehen

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“?

Enums um Verhalten erweitern 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 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 mit Feldern und Methoden
  2. Abstrakte Methoden in Enums
  3. EnumSet
  4. EnumMap
← Zurück zu Java Academy