Métodos abstratos em enums
Comportamento por constante.
Métodos abstratos em enums é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
Comportamento por constante
Às vezes, cada constante de enumeração precisa de um comportamento diferente, não apenas de dados diferentes.
Java permite declarar um método abstract na enumeração e substituí-lo para cada constante. Esse é o padrão de corpo de método específico da constante.
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));
}
}Como funciona
Cada constante com um corpo se torna uma subclasse anônima da enumeração.
O método abstract obriga cada constante a fornecer uma implementação, garantindo assim que o compilador verifique a completude.
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));
}
}Uma calculadora completa
As quatro operações aritméticas como constantes, cada uma com seu próprio corpo de 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));
}
}
}Combinando campos e comportamento
Você pode combinar um campo (um símbolo) com comportamento por constante. O campo identifica a operação; o método a executa.
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));
}
}Por que não usar uma seleção múltipla
Você poderia implementar apply com uma única estrutura de seleção sobre a constante, mas a abordagem do método abstract é mais segura.
Se você adicionar uma constante posteriormente, o compilador obrigará você a fornecer seu corpo. Uma estrutura de seleção poderia ignorar silenciosamente o novo 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));
}
}Métodos concretos ao lado de abstract
Uma enumeração pode combinar métodos abstract e concretos. Coloque a lógica compartilhada em um método concreto; mantenha a lógica variável em métodos abstract.
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));
}
}Enumerações de estratégia
Uma evolução é a enumeração de estratégia: as constantes delegam a uma enumeração de estratégia aninhada em vez de substituir o comportamento diretamente.
Isso é útil quando várias constantes compartilham o mesmo comportamento. Aqui, os dias úteis e os fins de semana diferem no cálculo do pagamento.
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));
}
}Enumeração com interface e corpos
Combine uma interface com corpos específicos para cada constante para obter o máximo de 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());
}
}Acessando campos a partir dos corpos
Um corpo específico de uma constante pode ler os próprios campos da constante, pois cada corpo é executado no contexto daquela instância.
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));
}
}Padrão e substituição
Você pode fornecer um padrão concreto no corpo da enumeração e substituí-lo apenas para as constantes que forem diferentes.
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"));
}
}Uma pequena máquina de estados
O comportamento por constante se destaca em máquinas de estados: cada estado conhece sua própria transição.
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ção rápida
Teste sua compreensão dos métodos abstract de enumerações.
Recapitulação
Você aprendeu sobre comportamento por constante:
- Declare um método abstract e substitua-o no corpo de cada constante.
- Cada constante se torna uma subclasse anônima.
- O compilador impõe a completude, superando uma estrutura de seleção.
- Combine campos, padrões concretos e interfaces para criar enumerações avançadas.
A seguir, o EnumSet de alto desempenho.
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());
}
}Perguntas Frequentes
A aula “Métodos abstratos em enums” é grátis?
Sim — o texto completo de “Métodos abstratos em enums” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Métodos abstratos em enums”?
Comportamento por constante. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Métodos abstratos em enums”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Enums com campos e métodos
- Métodos abstratos em enums
- EnumSet
- EnumMap