O Java enum é um recurso importante para permitir o armazenamento de um conjunto de valores constantes, ou seja, são valores relacionados a um elemento principal, que pode assumir diferentes valores. Imagine que temos uma aplicação que utilize a variável estação, que representa as estações do ano. Nesse cenário, teríamos apenas quatro valores possíveis para essa variável.

A utilização desse recurso requer algumas considerações, pois ele contém características que podem dificultar a manutenção do sistema, como não permitir a inclusão de novos valores sem editar o código fonte. Por isso, deve ser utilizado apenas para valores que realmente não sofrerão modificações, como para armazenar os dias da semana, os meses do ano etc.

Apesar disso, esse recurso oferece diversos benefícios, como evitar a necessidade de criarmos uma tabela no banco de dados para armazenar os valores declarados como enum, permitir o desenvolvimento de um código limpo e muito mais. Para demonstrar como utilizar enum em Java, preparamos este conteúdo com os seguintes tópicos:

• O que é o Java enum?
• Qual a sintaxe do Java enum?
• Java enum e herança: qual a relação?
• Sabia que values(), toString, ordinal() e valueOf() são métodos herdados do Java enum?
• Quais as diferenças entre Java enum e Classes?
• Por que usar Java enums? Quais as vantagens?
• Quais as desvantagens de usar Java enum?
• Como declarar um Java enum?
• Como iniciar os valores declarados no Java enum?
• Name: como imprimir um valor enum?
• Equals: vamos comparar valores enum?
• Como aplicar o Java enum na prática? Veja 3 exemplos de uso

Continue conosco e boa leitura!

O que é o Java enum?

O Java enum é um tipo de dado utilizado para armazenar um conjunto de valores constantes, ou seja, são valores fixos, que não podem ser modificados. Na prática, o enum é um tipo especial de classe que utiliza a palavra-chave enum ao ser declarado.

Os itens de um enum são separados por vírgula, e devem ser declarados com letra maiúscula. Vale ressaltar que a palavra enum representa a abreviação de enumerations, ou enumerações, em português.

Qual a sintaxe do Java enum?

A sintaxe do Java enum é:

modificadores_de_visibilidade enum nomeEnum { VALOR1, VALOR2, ..., VALORN }

Em que:

• modificadores_de_visibilidade: não é obrigatório e representa a autorização de uso do recurso por outras partes do código, como public, private e protected;
• enum: palavra-chave necessária para declarar uma classe do tipo enumerador em Java;
• nomeEnum: indica o nome de identificação do enum;
• VALOR1, VALOR2, …, VALORN: representam os valores específicos de cada constante, e devem ser declarados em maiúscula, obrigatoriamente.

Java enum e herança: qual a relação?

O tipo enum em Java herda as características da classe java.lang.Enum. Dessa forma, há um conjunto de propriedades e métodos disponíveis automaticamente quando criamos um tipo enum em uma aplicação.

Entretanto, o Java não aceita heranças múltiplas, ou seja, podemos estender uma classe apenas uma vez. Como o enum já é uma extensão de java.lang.Enum, não é possível estendê-lo novamente para outras classes.

Sabia que values(), toString, ordinal() e valueOf() são métodos herdados do Java enum?

Como mencionamos, o Java enum herda as características da classe java.lang.Enum, o que permite que ele tenha uma série de métodos herdados dessa classe. Confira alguns deles, a seguir.

Values(): como percorrer valores enum

O método values() retorna uma lista com valores de um tipo enum em uma variável do tipo array. Dessa forma, podemos utilizar uma estrutura de repetição como o laço for para percorrer os valores do array e retornar um ou mais itens para a aplicação. Veja o código, a seguir:

public class Main {
    public enum EstacoesDoAno{
        PRIMAVERA,
        VERAO,
        OUTONO,
        INVERNO
    }
    public static void main(String[] args) {
        for (EstacoesDoAno estacao : EstacoesDoAno.values()) {
            System.out.println(estacao);
        }
    }
 }
 /* Resultado:
 PRIMAVERA
 VERAO
 OUTONO
 INVERNO
 */

Perceba que declaramos o tipo enum EstacoesDoAno, com os respectivos valores. A seguir, utilizamos a estrutura de repetição for para percorrer os itens armazenados na variável “estacao”, que retorna os valores por meio da chamada ao método values() em “EstacoesDoAno.values()”.

toString(): descobrindo o nome de uma instância

O método toString() é utilizado quando queremos retornar o valor em string correspondente a determinada constante do tipo enum. Veja um exemplo utilizando o mesmo enum que criamos para o código anterior:

System.out.println((EstacoesDoAno.PRIMAVERA.toString()));

/* Resultado: PRIMAVERA */

ordinal(): descobrindo os índices das instâncias

O método ordinal() retorna o índice da constante correspondente no enum. Veja o trecho do código, a seguir:

EstacoesDoAno estacaoAtual[] = EstacoesDoAno.values();

for (EstacoesDoAno estacao : estacaoAtual)
{
    System.out.println("A estação " + estacao + " corresponde ao índice " + estacao.ordinal());
}
/* Resultado:

    A estação PRIMAVERA corresponde ao índice 0

    A estação VERAO corresponde ao índice 1

    A estação OUTONO corresponde ao índice 2

    A estação INVERNO corresponde ao índice 3    

*/

valueOf(): descobrindo a instância enum de um valor de string específico

O método valueOf() retorna uma string com o valor da constante correspondente. Caso o valor informado não exista, será retornada uma mensagem de erro para notificar que o conteúdo não foi encontrado. Sua sintaxe é:

nomeEnum.valueOf(“constante”)

Em que:

• nomeEnum: corresponde ao nome do enum;
• constante: representa o item a ser pesquisado no enum.

Veja um trecho de código:

System.out.println((EstacoesDoAno.valueOf("PRIMAVERA")));
/* Resultado: PRIMAVERA */

Quais as diferenças entre Java enum e Classes?

Como mencionamos, o enum é um tipo de classe, pois internamente ele é implementado como uma. Em razão disso, ele pode ter atributos, métodos, construtores e implementar interface como em qualquer outra classe.

A grande diferença é que as constantes enum são estáticas e finais (static e final). Para ficar mais claro, vamos relembrar o conceito dos modificadores static e final.

Quando declaramos um objeto como static, significa que ele pode ser acessado por toda a classe em que ele está inserido, ou seja, ele é compartilhado em todas as instâncias da classe, sem a necessidade de criar uma nova versão sempre que necessário.

A palavra-chave final indica que o objeto declarado é uma constante. Em razão disso, não pode sofrer modificações.

As constantes enum devem ser escritas em maiúscula e seus valores não podem ser modificados, como é possível fazer em uma classe. Além disso, não é possível utilizar a palavra-chave new para instanciar um enum, pois seu construtor é interno e privado.

Por que usar Java enums? Quais as vantagens?

Existem diversas razões para utilizar enums ao desenvolver uma aplicação. Confira as principais vantagens, a seguir.

Possibilita a escrita de um código mais limpo

Há uma infinidade de situações em que precisamos utilizar constantes que podem assumir diferentes valores, como os dias da semana, as estações do ano, os períodos de aulas e muito mais. Em qualquer um desses cenários, a utilização de enums facilita na escrita e na manutenção do código fonte.

Proporciona mais segurança ao tipo

Uma das características do enum é ser imutável, ou seja, não podemos modificar o valor definido, como fazemos em uma variável qualquer. Isso proporciona mais segurança, pois temos a certeza de que em nenhum momento os valores definidos poderão ser modificados na aplicação ou pela pessoa usuária.

Além disso, a linguagem Java é desenvolvida para proporcionar uma tipagem segura ou type-safety. Isso significa que, ao utilizarmos um tipo enum no código, e atribuirmos um valor a uma variável desse tipo, somente as constantes definidas serão aceitas.

Portanto, qualquer outro valor diferente do esperado retornará um erro de compilação ou até um alerta em tempo de desenvolvimento, dependendo do editor de código ou da IDE — Integrated Development Environment ou Ambiente de Desenvolvimento Integrado — que a pessoa programadora utilizar no momento. Dessa forma, há mais segurança ao evitar erros de programação na aplicação.

Permite a definição de atributos, construtores e métodos

A definição de atributos, construtores e métodos permite adicionar mais recursos ao enum. Dessa forma, podemos, por exemplo, definir os valores das constantes e criar um método para retornar um valor numérico, por exemplo, de acordo com a necessidade da aplicação.

Essa possibilidade é importante para o desenvolvimento de códigos encapsulados e reutilizáveis, o que é um dos princípios da programação orientada a objetos.

Quais as desvantagens de usar Java enum?

Assim como existem diversas vantagens em utilizar o Java enum, também podemos citar alguns pontos negativos desse recurso. Como mencionamos, o tipo enum é imutável, por isso, é importante utilizar esse recurso apenas em situações que não haverá a necessidade de modificação do conteúdo definido, como para definir os dias da semana e outros dados que não se modificam com frequência.

Exatamente por ser constante, os valores atribuídos a um enum só podem ser modificados por meio da edição do código fonte. Portanto, é necessário ter cuidado e atenção para que não haja necessidade de realizar manutenções do código em situações que poderiam ser evitadas.

Como declarar um Java enum?

Para declarar um enum, precisamos utilizar a palavra-chave enum, definir um nome e o conjunto de constantes. Veja um exemplo:

enum Periodo { MANHA, TARDE, NOITE }

A declaração do enum pode ser feita dentro ou fora de uma classe, entretanto, não pode ocorrer dentro de um método.

Depois que um tipo enum é criado, podemos declarar uma nova variável com esse tipo, entretanto, não podemos usar a palavra-chave new para instanciá-la. Na prática, as variáveis de um tipo enum existente são declaradas da mesma forma que os tipos primitivos, como char, int, boolean, entre outros.

Além disso, quando declaramos uma variável com um tipo enum, apenas os valores correspondentes a esse tipo podem ser armazenados na variável. Veja um código de exemplo:

public class Main {
    enum Periodo { MANHA, TARDE, NOITE};
 
    public static void main(String[] args) {
        Periodo periodoCurso;
        periodoCurso = Periodo.TARDE;
        System.out.println((periodoCurso));
 
    }
 }
 /* Resultado: TARDE */

No exemplo acima, declaramos o tipo enum Periodo dentro da classe Main, e utilizamos esse tipo de dado na variável periodoCurso, que declaramos no método main(). A seguir, atribuímos o valor TARDE a ela, e exibimos o seu conteúdo na tela.

Como iniciar os valores declarados no Java enum?

Os atributos de um enum podem ter valores associados a eles. Podemos criar um enum com os meses do ano e ter os valores numéricos correspondentes a eles, por exemplo. Nesse caso, a declaração do enum deve ser:

enum MesesDoAno {
   JANEIRO(1),
   FEVEREIRO(2),
   MARCO(3)
}

Perceba que colocamos o número desejado entre parênteses ao lado da definição das constantes do enum. Entretanto, só isso não é o suficiente para que o Java entenda a correspondência entre os valores. Portanto, precisamos inicializar esses atributos.

Dessa forma, será possível utilizar tanto o valor descritivo quanto o numérico. Veja o código, a seguir.

public class Main {
    public enum MesesDoAno {
        JANEIRO(1, "Janeiro"),
        FEVEREIRO(2, "Fevereiro"),
        MARCO(3, "Março");
 
        private final int valor;
        private final String descricao;
 
        MesesDoAno(int valor, String descricao) {
            this.valor = valor;
            this.descricao = descricao;
        }
 
        public int getValor() {
            return this.valor;
        }
        public String getDescricao() {
            return this.descricao;
        }
    }
 
    public static void main(String[] args) {
 
        MesesDoAno mes = MesesDoAno.FEVEREIRO;
        System.out.println("Valor da constante: " + mes + "\n" + "Valor numérico do mês: " + mes.getValor() + "\n" + "Descrição do mês: " + mes.getDescricao());
 
    }
 }
/* Resultado: 
 Valor da constante: FEVEREIRO
 Valor numérico do mês: 2
 Descrição do mês: Fevereiro
*/

Perceba que, ao declararmos o enum, também fazemos isso com mais dois campos que utilizaremos para definir o valor e a descrição de cada atributo. Eles foram declarados como private, pois só podem ser acessados pelo escopo da definição do enum.

A seguir, criamos o construtor MesesDoAno() e adicionamos dois parâmetros: valor e descrição, que são necessários para atribuir os respectivos valores a cada constante. Depois, criamos dois métodos: getValor() e getDescricao(), que retornam os valores correspondentes.

Por fim, utilizamos o enum no método main(), em que atribuímos o item FEVEREIRO à variável “mês” do tipo enum. O último comando exibe na tela o valor da variável mês, e recuperamos o valor e a descrição definidos no enum, por meio da chamada aos respectivos métodos.

Name: como imprimir um valor enum?

O método name() é mais uma opção para recuperarmos o nome que atribuímos a cada constante da classe enum. Se adicionarmos o código abaixo no método main(), do exemplo acima, teremos os seguintes resultados exibidos na tela:

System.out.println(mes.name()); /*Resultado: FEVEREIRO */
System.out.println(MesesDoAno.MARCO.name()); /* Resultado: MARCO */

Perceba que, na primeira instrução, utilizamos o método name() diretamente sobre a variável mês. Isso porque ela contém apenas a constante FEVEREIRO do tipo enum MesesDoAno. Já no comando seguinte, precisamos especificar de qual constante queremos o nome, já que MesesDoAno contém todas as constantes definidas no enum.

Equals: vamos comparar valores enum?

Podemos comparar os valores definidos em um enum com os valores atribuídos em uma variável. Para isso, utilizamos o método equals(), que compara se dois objetos são iguais. Para demonstrar como esse recurso funciona, vamos utilizar o mesmo enum MesesDoAno que criamos acima. Veja o trecho do código, a seguir.

MesesDoAno mesAno = MesesDoAno.FEVEREIRO;
 if (mesAno.equals(MesesDoAno.FEVEREIRO))
    System.out.println("Os valores são iguais");
 else
    System.out.println("Os valores são diferentes");
 /* Resultado: "Os valores são iguais */

No código acima, criamos uma variável do tipo enum chamada mesAno e atribuímos o valor FEVEREIRO a ela. Em seguida utilizamos a estrutura condicional if e o método equals() para comparar se o valor mesAno é igual a MesesDoAno.FEVEREIRO. Por fim, mostramos o resultado que, nesse caso, são iguais.

É importante ressaltar que o método equals() também verifica se o tipo de dado comparado é o mesmo. Veja o exemplo a seguir:

String ms = "FEVEREIRO";
if (ms.equals(MesesDoAno.FEVEREIRO))
    System.out.println("Os valores são iguais");
else
    System.out.println("Os valores são diferentes");
/* Resultado: "Os valores são diferentes */

No código acima, criamos uma variável do tipo String e atribuímos o valor “FEVEREIRO”. Se compararmos os valores, o resultado será diferente, pois um objeto é String e o outro é enum.

Para realizar essa comparação com sucesso, precisamos utilizar o método toString() na constante enum. Assim, podemos converter o valor da constante enum ao tipo String. Veja como fica o código:

String ms = "FEVEREIRO";
if (ms.equals(MesesDoAno.FEVEREIRO.toString()))
    System.out.println("Os valores são iguais");
else
    System.out.println("Os valores são diferentes");
/* Resultado: "Os valores são iguais */

Como aplicar Java enum na prática? Veja 3 exemplos de uso

Nada melhor que conferir alguns exemplos práticos de como utilizar esse recurso. Confira, a seguir, diferentes maneiras de utilizar o Java enum.

1. Enum com valores numéricos

Podemos associar cada constante em um enum a um valor numérico correspondente. Como mencionamos, precisamos codificar essa associação.

Para isso, definimos o campo valor e criamos o construtor DiasDaSemana associado a um valor numérico “DiasDaSemana(int valor)”. A seguir, criamos o método getValor() para recuperar o conteúdo correspondente. Veja o código, a seguir:

public class Main {
 
    public enum DiasDaSemana{
        SEGUNDA(1),
        TERCA(2),
        QUARTA(3),
        QUINTA(4),
        SEXTA(5),
        SABADO(6),
        DOMINGO(7);
 
        private final int valor;
 
        private DiasDaSemana(int valor) {
            this.valor = valor;
        }
 
        public int getValor() {
            return this.valor;
        }
    }
    public static void main(String[] args) {
        System.out.println("O dia da semana: " + DiasDaSemana.QUINTA + " corresponde ao valor: " + DiasDaSemana.QUINTA.getValor());
    }
 }
 /* Resultado:
 O dia da semana: QUINTA corresponde ao valor: 4
 
 */

2. Enum com iteração com loop de repetição for

Podemos percorrer os itens de um enum com o loop de repetição for, que executa um ou vários comandos até que uma condição seja atendida. Quando utilizado com enum, precisamos recuperar a lista das constantes definidas por meio do método values().

Dessa forma, todos os valores podem ser processados. Veja o código a seguir para exibirmos todos os dias da semana:

public class Main {
 
    public enum DiasDaSemana{
        SEGUNDA(1),
        TERCA(2),
        QUARTA(3),
        QUINTA(4),
        SEXTA(5),
        SABADO(6),
        DOMINGO(7);
 
        private final int valor;
 
        private DiasDaSemana(int valor) {
            this.valor = valor;
        }
 
        public int getValor() {
            return this.valor;
        }
    }
    public static void main(String[] args) {
 
        for (DiasDaSemana dia : DiasDaSemana.values()) {
            System.out.println("O dia " + dia + " corresponde ao valor: " + dia.getValor());
        }
    }
 }
 /* Resultado:
 O dia SEGUNDA corresponde ao valor: 1
 O dia TERCA corresponde ao valor: 2
 O dia QUARTA corresponde ao valor: 3
 O dia QUINTA corresponde ao valor: 4
 O dia SEXTA corresponde ao valor: 5
 O dia SABADO corresponde ao valor: 6
 O dia DOMINGO corresponde ao valor: 7
 */

3. Enum com a estrutura de repetição switch e com método para retornar o valor

A estrutura de repetição switch é utilizada quando queremos avaliar uma expressão inicial e executar um bloco de códigos caso a condição seja verdadeira. Na prática, o valor da expressão é comparado com o conteúdo de cada case e, ao encontrar a correspondência, o código associado é executado.

Podemos utilizar essa estrutura para avaliar uma variável que contenha o valor de uma constante definida em um enum, e definir em cada case determinada ação para cada constante do enum. Veja o código a seguir, em que encontramos o dia da semana:

public class Main {
    public enum DiasDaSemana{
        SEGUNDA(1, "Segunda-feira"),
        TERCA(2, "Terça-feira"),
        QUARTA(3, "Quarta-feira"),
        QUINTA(4, "Quinta-feira"),
        SEXTA(5, "Sexta-feira"),
        SABADO(6, "Sábado"),
        DOMINGO(7, "Domingo");
 
        private final int valor;
        private final String dia;
 
        DiasDaSemana(int valor, String dia) {
            this.valor = valor;
            this.dia = dia;
        }
 
    }
    public static void main(String[] args) {
        DiasDaSemana diaAtual = DiasDaSemana.SEGUNDA;
        switch (diaAtual){
            case SEGUNDA:
                System.out.println(diaAtual.dia);
                break;
            case TERCA:
                System.out.println(diaAtual.dia);
                break;
            default:
                System.out.println("Outro dia da semana");
        }
    }
 }
/*Resultado:
Segunda-feira
*/

No exemplo acima atribuímos o valor SEGUNDA à variável diaAtual. Em seguida, utilizamos os valores das constantes do enum DiasDaSemana para identificar o valor correspondente e exibir a descrição desejada.

Também podemos utilizar um valor inteiro para encontrar o valor procurado. Veja o trecho de código, a seguir:

public static void main(String[] args) {
        int diaAtual = 2;
        switch (diaAtual){
            case 1:
                System.out.println(DiasDaSemana.SEGUNDA.dia);
                break;
            case 2:
                System.out.println(DiasDaSemana.TERCA.dia);
                break;
            default:
                System.out.println("Outro dia da semana");
        }
    }
/* Resultado
 Terça-feira
*/

O Java enum é um poderoso recurso da linguagem Java que proporciona diversos benefícios à aplicação e à pessoa programadora, pois ele ajuda a tornar o código mais limpo, reaproveitável, fácil de entender e de realizar manutenções. E não é só isso: ele contém uma série de métodos herdados e permite a criação de atributos e métodos próprios para adicionar ainda mais funcionalidade à aplicação.

Quer aprender a programar e não sabe por onde começar? Faça o download do currículo do curso de desenvolvimento web da Trybe e veja como podemos ajudar nisso.