Enums com campos e métodos
Adicione comportamento a enums.
Enums com campos e métodos é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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.
As enumerações são classes completas
Uma enumeração do Java é muito mais do que uma lista de constantes. Ela é uma classe real cujas instâncias são as constantes.
Isso significa que as enumerações podem ter campos, construtores e métodos, como qualquer outra classe.
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());
}
}Adicionando um campo
Você pode associar dados a cada constante. Declare um campo final e um construtor, depois passe os valores entre parênteses após cada constante.
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());
}
}O construtor de enumeração é privado
Os construtores de enumeração são implicitamente privados. Não é possível chamar new em uma enumeração; a JVM cria as constantes uma única vez, quando a classe é carregada.
Isso garante um conjunto fixo e finito de instâncias.
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);
}
}Vários campos
Uma constante pode armazenar várias informações. Aqui, cada planeta armazena tanto a massa quanto o raio.
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());
}
}Métodos de instância
Os métodos de uma enumeração podem calcular resultados a partir dos próprios campos da constante, assim como os métodos de instância comuns.
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());
}
}Nome predefinido e ordinal
Cada enumeração recebe name() (o identificador exato) e ordinal() (sua posição baseada em zero).
Prefira armazenar seus próprios dados em vez de depender de ordinal(), que deixa de funcionar se você reordenar as constantes.
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 e valueOf
O compilador gera dois auxiliares estáticos:
values()retorna um vetor com todas as constantes.valueOf(String)localiza uma constante pelo nome e lança uma exceção se ela não for encontrada.
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);
}
}Substituindo toString
Você pode substituir toString() para fornecer rótulos mais amigáveis, mantendo o nome da constante para o código.
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);
}
}Enumerações em seleção múltipla
As enumerações funcionam bem com estruturas de seleção múltipla. Com as expressões modernas de seleção múltipla, você obtém verificações de completude e não há queda automática para o próximo caso.
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));
}
}Mapas estáticos de pesquisa
Um padrão comum é um mapa estático que parte de um campo e retorna à constante, criado uma vez em um inicializador estático.
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("-"));
}
}Enumerações implementam interfaces
Uma enumeração pode implementar uma interface, permitindo que as constantes sejam usadas em código de finalidade geral.
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());
}
}Verificação rápida
Teste sua compreensão dos campos de enumerações.
Recapitulação
Você aprendeu que as enumerações são classes completas:
- As constantes podem conter campos definidos por meio de um construtor privado.
- As enumerações podem ter métodos de instância e substituir
toString(). values()evalueOf()são gerados para você.- As enumerações podem implementar interfaces e devem preferir campos a
ordinal().
A seguir, comportamento por constante com métodos abstract.
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());
}
}Perguntas Frequentes
A aula “Enums com campos e métodos” é grátis?
Sim — o texto completo de “Enums com campos e métodos” é 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 “Enums com campos e métodos”?
Adicione comportamento a enums. 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 1 de 4.
Quanto tempo leva a aula “Enums com campos e métodos”?
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