1. Antecedentes
Antes da introdução do idioma Java, o padrão comum para indicar um tipo de enumeração é declarar um conjunto de constantes int. O código que costumamos definir antes de usar o método estático final público é o seguinte, usando 1 para representar a primavera, 2 para representar o verão, 3 para representar o outono e 4 para representar o inverno.
Public Class Season {public static final int spring = 1; public static final int verão = 2; public static final int outono = 3; public static final int inverno = 4;}Este método é chamado de padrão de enumeração int. Mas o que há de errado com este modelo? Nós o usamos há tanto tempo, então não deve haver problema. Normalmente, o código que escrevemos leva em consideração sua segurança, facilidade de uso e legibilidade. Primeiro, vamos considerar seu tipo de segurança. Claro que esse padrão não é seguro para o tipo. Por exemplo, projetamos uma função que requer um certo valor na primavera, verão, outono e inverno. No entanto, com o tipo int, não podemos garantir que o valor passado seja legal. O código se parece com o seguinte:
Private String getChineSeason (int temporada) {stringbuffer resultado = new StringBuffer (); switch (estação) {case Season.spring: resultado.append ("spring"); quebrar; Caso Season.Summer: Result.Append ("Summer"); quebrar; estação do caso. Autumn: resultado.append ("outono"); quebrar; Case Season.Winter: Result.Append ("Winter"); quebrar; Padrão: Result.Append ("Temporada Nenhuma na Terra"); quebrar; } return result.toString (); } public void Dosomething () {System.out.println (this.getChineseason (temporada.spring)); // Este é um cenário normal System.out.println (this.getchineseseason (5)); // Este é um cenário anormal, que leva a um tipo de insecução}O programa GetChineSeason (temporada.spring) é o método que esperamos usar. Mas o GetChineSeason (5) obviamente não é o caso, e a compilação é muito passiva. Não sabemos o que acontece em tempo de execução. Obviamente, isso não está em conformidade com o tipo de segurança dos programas Java.
Em seguida, vamos considerar a legibilidade desse padrão. Na maioria das ocasiões ao usar enumerações, preciso ser conveniente para obter expressões de string do tipo enum. Se imprimirmos as constantes de enumeração int, o que vemos é um conjunto de números, o que não é muito útil. Podemos pensar em usar constantes de string em vez de constantes int. Embora forneça seqüências imprimíveis para essas constantes, causa problemas de desempenho, porque depende de operações de comparação de string, portanto esse padrão também é algo que não esperamos. Considerando a segurança do tipo e a legibilidade do programa, são reveladas as desvantagens dos padrões de enumeração INT e String. Felizmente, desde a liberação do Java 1.5, foi proposta outra solução alternativa que evita as desvantagens dos padrões de enumeração INT e String e oferece muitos benefícios adicionais. Esse é o tipo de enumeração. Os capítulos a seguir introduzirão as definições, recursos, cenários de aplicativos e vantagens e desvantagens dos tipos de enumeração.
2. Definição <br /> enum tipo refere -se a um tipo legal composto por um conjunto fixo de constantes. Em Java, a palavra -chave enum é usada para definir um tipo de enumeração. A seguir, é apresentada a definição do tipo Java Enum.
Public Enum Season {Spring, Summer, Autumn, Winer;} 3. Recursos
As declarações de Java que definem os tipos de enum são muito simples. Tem as seguintes características:
1) Use o nome da palavra -chave 2) Nome do tipo, como a temporada 3) uma sequência de valores permitidos, como as enumerações da primavera, verão, outono, inverno e estações definidas acima de 4) podem ser definidas separadamente em um arquivo ou incorporadas em outras classes Java.
Além desses requisitos básicos, os usuários têm outras opções
5) As enumerações podem implementar uma ou mais interfaces (interfaces) 6) novas variáveis podem ser definidas 7) Novo método pode ser definido 8) Classes que variam de acordo com valores de enumeração específicos podem ser definidos
4. Cenários de aplicação
Tomando o tipo de segurança mencionada em segundo plano como exemplo, reescreva esse código com um tipo de enumeração. O código é o seguinte:
Public Enum Season {Spring (1), verão (2), outono (3), inverno (4); Código INT privado; temporada privada (código int) {this.code = code; } public int getCode () {Return Code; }} classe pública usaason { / ** * Converta a estação em inglês para a temporada chinesa * @param temporada * @return * / public String getChineSeason (temporada de temporada) {stringbuffer resultado = new StringBuffer (); Switch (estação) {Case Spring: Result.Append ("[Chinês: Primavera, constante de enumeração:" + temporada.name () + ", dados:" + temporada.getCode () + "]"); quebrar; case outono: resultado.append ("[chinês: outono, constante de enumeração:" + temporada.name () + ", dados:" + temporada.getCode () + "]"); quebrar; Caso verão: resultado.append ("[Chinês: verão, constante de enumeração:" + temporada.name () + ", dados:" + temporada.getCode () + "]"); quebrar; Caso Inverno: Result.Append ("[Chinês: inverno, constantes de enumeração:" + temporada.name () + ", dados:" + temporada.getCode () + "]"); quebrar; padrão: resultado.append ("Temporada sem terra" + temporada.name ()); quebrar; } return result.toString (); } public void Dosomething () {for (temporada s: temporada.values ()) {System.out.println (getChineseason (s)); // Este é um cenário normal} //system.out.println(getChineseason(5)); // O compilador já está falhando aqui, o que garante a segurança do tipo} public static void main (string [] arg) {usaason usaason = new usaason (); usaason.Dosomething (); }}[Chinês: primavera, constante de enumeração: primavera, dados: 1] [Chinês: verão, constante de enumeração: verão, dados: 2] [Chinês: outono, constante de enumeração: outono, dados: 3] [Chinês: inverno, constante de enumeração: inverno, dados: 4]
Aqui está uma pergunta: por que eu quero adicionar o domínio ao tipo enum? O objetivo é associar os dados a suas constantes. Por exemplo, 1 representa a primavera e 2 representa o verão.
5. Resumo
Então, quando você deve usar enums? Sempre que um conjunto fixo de constantes é necessário, como os dias de uma semana, as estações do ano etc. ou uma coleção de todos os valores que ele contém antes de compilar. A enumeração Java 1.5 pode atender aos requisitos da maioria dos programadores, e suas características concisas e fáceis de usar são muito proeminentes.
6. Uso
Uso 1: constante
cor de enum pública {vermelho, verde, em branco, amarelo}Uso 2: Switch
Sinal de enumeração {verde, amarelo, vermelho} public classe Trafficlight {signal color = signal.red; public void alteração () {switch (color) {case Red: color = signal.green; quebrar; Case amarelo: cor = sinalização.red; quebrar; case verde: cor = sinalize.yellow; quebrar; }}}Uso 3: adicione um novo método à enumeração
cor da enumeração pública {Red ("Red", 1), Green ("Green", 2), Blank ("White", 3), Yello ("Amarelo", 4); // Nome da sequência privada variável do membro; índice privado int; // Método de construção de cores privadas (nome da string, int index) {this.name = name; this.index = index; } // método normal public static string getName (int index) {for (color c: color.values ()) {if (c.getIndex () == index) {return c.name; }} retornar nulo; } // obtenha o método definido public string getName () {return name; } public void setName (nome da string) {this.name = name; } public int getIndex () {return index; } public void setIndex (int index) {this.index = index; }}Uso 4: Métodos para substituir a enumeração
cor da enumeração pública {Red ("Red", 1), Green ("Green", 2), Blank ("White", 3), Yello ("Amarelo", 4); // Nome da sequência privada variável do membro; índice privado int; // Método de construção de cores privadas (nome da string, int index) {this.name = name; this.index = index; } // Substituir o método @Override public string tostring () {return this.index+"_"+this.name; }}Uso 5: implemente a interface
Comportamento de interface pública {void print (); String getinfo (); } A cor pública enum implementa o comportamento {Red ("Red", 1), Green ("Green", 2), Blank ("White", 3), Yello ("Amarelo", 4); // Nome da sequência privada variável do membro; índice privado int; // Método de construção de cores privadas (nome da string, int index) {this.name = name; this.index = index; } // Método da interface @Override public String getinfo () {return this.name; } // Método da interface @Override public void print () {System.out.println (this.index+":"+this.name); }}Uso 6: Use interface para organizar a enumeração
Public Interface Food {Enum Coffee implementa alimentos {Black_coffee, Decaf_coffee, Latte, Cappuccino} Enum sobremesas implementos alimentos {frutas, bolo, gelato}}}O exposto acima é tudo sobre este artigo, espero que seja útil para o aprendizado de todos.