Abstrakte Methoden in Enums
Verhalten pro Konstante
Abstrakte Methoden in Enums 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.
Verhalten pro Konstante
Manchmal benötigt jede Enum-Konstante unterschiedliches Verhalten und nicht nur unterschiedliche Daten.
Java ermöglicht es Ihnen, eine abstrakte Methode im Enum zu deklarieren und sie für jede Konstante zu überschreiben. Dies ist das Muster des konstantenspezifischen Methodenrumpfs.
public class Main {
enum Operation {
PLUS { public int apply(int a, int b) { return a + b; } },
MINUS { public int apply(int a, int b) { return a - b; } };
public abstract int apply(int a, int b);
}
public static void main(String[] args) {
System.out.println(Operation.PLUS.apply(3, 4));
System.out.println(Operation.MINUS.apply(10, 6));
}
}So funktioniert es
Jede Konstante mit einem Methodenrumpf wird zu einer anonymen Unterklasse des Enums.
Die abstrakte Methode zwingt jede Konstante, eine Implementierung bereitzustellen, sodass der Compiler die Vollständigkeit garantiert.
public class Main {
enum Operation {
TIMES { public int apply(int a, int b) { return a * b; } };
public abstract int apply(int a, int b);
}
public static void main(String[] args) {
// The constant is an instance of a generated subclass
System.out.println(Operation.TIMES.getClass().getSimpleName().isEmpty()
? "anonymous subclass" : Operation.TIMES.apply(6, 7));
}
}Ein vollständiger Taschenrechner
Die vier arithmetischen Operationen als Konstanten, jeweils mit einem eigenen apply-Methodenrumpf.
public class Main {
enum Operation {
PLUS { public double apply(double a, double b) { return a + b; } },
MINUS { public double apply(double a, double b) { return a - b; } },
TIMES { public double apply(double a, double b) { return a * b; } },
DIVIDE{ public double apply(double a, double b) { return a / b; } };
public abstract double apply(double a, double b);
}
public static void main(String[] args) {
double x = 6, y = 3;
for (Operation op : Operation.values()) {
System.out.printf("%s -> %.1f%n", op, op.apply(x, y));
}
}
}Felder und Verhalten kombinieren
Sie können ein Feld (ein Symbol) mit konstantenspezifischem Verhalten kombinieren. Das Feld bezeichnet die Operation; die Methode führt sie aus.
public class Main {
enum Operation {
PLUS("+") { public double apply(double a, double b) { return a + b; } },
MINUS("-") { public double apply(double a, double b) { return a - b; } };
private final String symbol;
Operation(String symbol) { this.symbol = symbol; }
public abstract double apply(double a, double b);
@Override public String toString() { return symbol; }
}
public static void main(String[] args) {
Operation op = Operation.PLUS;
System.out.println("2 " + op + " 3 = " + op.apply(2, 3));
}
}Warum nicht switch?
Sie könnten apply mit einem einzigen switch über die Konstante implementieren, aber der Ansatz mit der abstrakten Methode ist sicherer.
Wenn Sie später eine Konstante hinzufügen, zwingt der Compiler Sie, deren Methodenrumpf bereitzustellen. Ein switch könnte den neuen Fall stillschweigend übergehen.
public class Main {
enum Op {
SQUARE { public int apply(int n) { return n * n; } },
CUBE { public int apply(int n) { return n * n * n; } };
public abstract int apply(int n);
}
public static void main(String[] args) {
System.out.println(Op.SQUARE.apply(5));
System.out.println(Op.CUBE.apply(3));
}
}Konkrete Methoden neben abstrakten
Ein Enum kann abstrakte und konkrete Methoden kombinieren. Gemeinsame Logik gehört in eine konkrete Methode; variierende Logik bleibt abstrakt.
public class Main {
enum Shape {
CIRCLE { public double area(double x) { return Math.PI * x * x; } },
SQUARE { public double area(double x) { return x * x; } };
public abstract double area(double x);
public String report(double x) { return this + " area = " + area(x); }
}
public static void main(String[] args) {
System.out.println(Shape.CIRCLE.report(2));
}
}Strategie-Enums
Eine Weiterentwicklung ist das Strategie-Enum: Konstanten delegieren an ein verschachteltes Strategie-Enum, statt Methoden direkt zu überschreiben.
Das ist nützlich, wenn mehrere Konstanten dasselbe Verhalten aufweisen. Hier unterscheiden sich Werktage und Wochenenden bei der Lohnberechnung.
public class Main {
enum PayType {
WEEKDAY { int overtime(int mins) { return mins; } },
WEEKEND { int overtime(int mins) { return mins * 2; } };
abstract int overtime(int mins);
int pay(int mins) { return mins + overtime(Math.max(0, mins - 480)); }
}
public static void main(String[] args) {
System.out.println("Weekend pay: " + PayType.WEEKEND.pay(540));
}
}Enum mit Interface und Methodenrümpfen
Kombinieren Sie ein Interface mit konstantenspezifischen Methodenrümpfen für maximale Polymorphie.
public class Main {
interface Command { String run(); }
enum Action implements Command {
START { public String run() { return "starting..."; } },
STOP { public String run() { return "stopping..."; } };
}
public static void main(String[] args) {
for (Action a : Action.values()) System.out.println(a.run());
}
}Auf Felder aus Methodenrümpfen zugreifen
Ein konstantenspezifischer Methodenrumpf kann auf die eigenen Felder der Konstante zugreifen, da jeder Methodenrumpf im Kontext dieser Instanz ausgeführt wird.
public class Main {
enum Tax {
STANDARD(0.20) { double apply(double amt) { return amt * (1 + rate); } },
REDUCED(0.05) { double apply(double amt) { return amt * (1 + rate); } };
protected final double rate;
Tax(double rate) { this.rate = rate; }
abstract double apply(double amt);
}
public static void main(String[] args) {
System.out.printf("%.2f%n", Tax.STANDARD.apply(100));
}
}Standard implementieren, dann überschreiben
Sie können im Enum-Rumpf eine konkrete Standardimplementierung angeben und sie nur für die Konstanten überschreiben, die davon abweichen.
public class Main {
enum Notifier {
EMAIL,
SMS { String send(String m) { return "SMS: " + m; } };
String send(String m) { return "EMAIL: " + m; }
}
public static void main(String[] args) {
System.out.println(Notifier.EMAIL.send("hi"));
System.out.println(Notifier.SMS.send("hi"));
}
}Eine kleine Zustandsmaschine
Konstantenspezifisches Verhalten kommt in Zustandsmaschinen besonders gut zur Geltung: Jeder Zustand kennt seinen eigenen Übergang.
public class Main {
enum State {
IDLE { State next() { return RUNNING; } },
RUNNING { State next() { return DONE; } },
DONE { State next() { return DONE; } };
abstract State next();
}
public static void main(String[] args) {
State s = State.IDLE;
for (int i = 0; i < 3; i++) { System.out.println(s); s = s.next(); }
System.out.println(s);
}
}Kurzer Test
Testen Sie Ihr Verständnis von abstrakten Enum-Methoden.
Zusammenfassung
Sie haben Verhalten pro Konstante gelernt:
- Deklarieren Sie eine abstrakte Methode und überschreiben Sie sie im Rumpf jeder Konstante.
- Jede Konstante wird zu einer anonymen Unterklasse.
- Der Compiler erzwingt die Vollständigkeit und ist damit sicherer als ein switch.
- Kombinieren Sie Felder, konkrete Standardimplementierungen und Interfaces für vielseitige Enums.
Als Nächstes geht es um das besonders leistungsfähige EnumSet.
public class Main {
enum E { A { int v() { return 1; } }; abstract int v(); }
public static void main(String[] args) {
System.out.println("Abstract enum recap: " + E.A.v());
}
}Häufig gestellte Fragen
Ist die Lektion „Abstrakte Methoden in Enums“ kostenlos?
Ja — der vollständige Text von „Abstrakte Methoden in Enums“ 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 „Abstrakte Methoden in Enums“?
Verhalten pro Konstante 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 „Abstrakte Methoden in Enums“?
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
- Enums mit Feldern und Methoden
- Abstrakte Methoden in Enums
- EnumSet
- EnumMap