Metodi astratti negli enum
Comportamento specifico per costante
Metodi astratti negli enum è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Comportamento specifico per costante
A volte ogni costante di un enum richiede un comportamento diverso, non solo dati diversi.
Java consente di dichiarare un metodo astratto nell'enum e di sovrascriverlo per ogni costante. Questo è il modello dei corpi di metodo specifici per costante.
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));
}
}Come funziona
Ogni costante con un corpo diventa una sottoclasse anonima dell'enum.
Il metodo astratto obbliga ogni costante a fornire un'implementazione, quindi il compilatore garantisce la completezza.
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));
}
}Un calcolatore completo
Le quattro operazioni aritmetiche come costanti, ognuna con il proprio corpo di apply.
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));
}
}
}Combinare campi e comportamento
È possibile combinare un campo (un simbolo) con un comportamento specifico per costante. Il campo descrive l'operazione, mentre il metodo la esegue.
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));
}
}Perché non usare switch?
Potrebbe implementare apply con un unico switch sulla costante, ma l'approccio basato sul metodo astratto è più sicuro.
Se in seguito aggiunge una costante, il compilatore La obbliga a fornirne il corpo. Uno switch potrebbe ignorare silenziosamente il nuovo caso.
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));
}
}Metodi concreti insieme a quelli astratti
Un enum può combinare metodi astratti e concreti. La logica condivisa va inserita in un metodo concreto, mentre quella variabile rimane astratta.
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));
}
}Enum strategia
Un'evoluzione di questo approccio è lo strategy enum: le costanti delegano a un enum strategia annidato invece di sovrascrivere direttamente il comportamento.
È utile quando diverse costanti condividono lo stesso comportamento. In questo caso, giorni feriali e fine settimana differiscono nel calcolo della retribuzione.
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 con interfaccia e corpi
Combini un'interfaccia con corpi specifici per costante per ottenere il massimo polimorfismo.
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());
}
}Accedere ai campi dai corpi
Un corpo specifico per costante può leggere i campi della propria costante, poiché ogni corpo viene eseguito nel contesto di quell'istanza.
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));
}
}Impostazione predefinita e sovrascrittura
È possibile fornire un'implementazione concreta predefinita nel corpo dell'enum e sovrascriverla solo per le costanti che si comportano diversamente.
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"));
}
}Una piccola macchina a stati
Il comportamento specifico per costante è particolarmente efficace nelle macchine a stati: ogni stato conosce la propria transizione.
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);
}
}Verifica rapida
Verifichi la Sua comprensione dei metodi astratti degli enum.
Riepilogo
Ha imparato a definire un comportamento specifico per costante:
- Dichiarare un metodo astratto e sovrascriverlo nel corpo di ogni costante.
- Ogni costante diventa una sottoclasse anonima.
- Il compilatore impone la completezza, offrendo maggiori garanzie di uno switch.
- Combinare campi, implementazioni concrete predefinite e interfacce per creare enum più ricchi.
Prossimamente: EnumSet ad alte prestazioni.
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());
}
}Domande Frequenti
La lezione «Metodi astratti negli enum» è gratuita?
Sì — il testo completo di «Metodi astratti negli enum» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «Metodi astratti negli enum»?
Comportamento specifico per costante Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Metodi astratti negli enum»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Enum con campi e metodi
- Metodi astratti negli enum
- EnumSet
- EnumMap