conceito
O nome completo da enum é a enumeração, que é um novo recurso introduzido no JDK 1.5.
Em Java, o tipo modificado pela palavra -chave enum é o tipo enum. O formulário é o seguinte:
cor enum {vermelho, verde, azul}Se a enumeração não adicionar nenhum método, o valor da enumeração padrão a um valor ordenado a partir de 0. Tomando o tipo de enumeração de cores como exemplo, suas constantes de enumeração são vermelhas: 0, verde: 1 e azul: 2 em sequência
Os benefícios da enumeração: as constantes podem ser organizadas e gerenciadas de maneira unificada.
Cenários de aplicação típicos para enumeração: códigos de erro, máquinas de estado, etc.
A natureza dos tipos de enumeração
Embora enum pareça um novo tipo de dados, na verdade, a Enum é uma classe restrita e tem seu próprio método.
Ao criar uma enumeração, o compilador gerará uma classe relacionada para você, que é herdada de java.lang.Enum .
Declaração da classe java.lang.Enum
classe abstrata pública enum <e estende enum <e>> implementa comparável <e>, serializável {...}Métodos de enumeração
Em enum, são fornecidos alguns métodos básicos:
values() : retorna uma matriz de instâncias de enum, e os elementos nessa matriz são estritamente mantidos na ordem em que são declarados em enum.
name() : retorna o nome da instância.
ordinal() : retorna a ordem quando a instância é declarada, a partir de 0.
getDeclaringClass() : Retorna o tipo enum ao qual a instância pertence.
equals() : determina se é o mesmo objeto.
Você pode usar == para comparar instâncias enum .
Além disso, java.lang.Enum implementa as interfaces Comparable e Serializable , para que o método compareto () também seja fornecido.
Exemplo: métodos básicos de mostrar enum
public ======================================================================= para (cor. System.out.println ("=============== Imprima todo o tamanho ========================================== para (tamanho S: Size.Values ()) {System.out.println (S +" Sptrlin (Size. Tamanho. System.It.println ("Nome verde ():" Green.getDeclaringClass ()); Green.equals (color.green)); }}Saída
=============================== Red Orden: getDecLaringClass (): classe org.zp.javase.enumeration.enumdemo $ colorgreen hashcode (): 460141958Green compareto color.Green: 0Green é igual à cor.
Características da enumeração
As características da enumeração são resumidas em uma frase:
Além de não conseguir herdar, enum pode basicamente ser considerada uma classe regular.
Mas essa frase precisa ser entendida separadamente, vamos explicar em detalhes.
A enumeração pode adicionar métodos
No capítulo conceitual, o valor da enumeração padrão é um valor ordenado a partir de 0. Então a pergunta é: como atribuir valores à enumeração exibida.
Java não permite o uso de = atribuir valores para enumes
Se você foi exposto a C/C ++, definitivamente pensará no símbolo de atribuição = naturalmente. Na linguagem C/C ++, a enumeração pode ser atribuída a constantes de enumeração com o símbolo de atribuição = exibido; No entanto, infelizmente, o símbolo de atribuição = atribuído às constantes da enum não é permitido na sintaxe Java.
Exemplo: Declaração de Enumeração na linguagem C/C ++
typedef enum {um = 1, dois, três = 3, dez = 10} número;Enum pode adicionar métodos comuns, métodos estáticos, métodos abstratos e métodos construtores.
Embora o Java não possa atribuir diretamente valores às instâncias, ele possui uma solução ainda melhor: adicione métodos para enum para implementar indiretamente as atribuições de exibição.
Ao criar enum , você pode adicionar vários métodos e até construtores.
Observe um detalhe: se você deseja definir um método para uma enumeração, você deve adicionar um ponto e vírgula no final da última instância da enumeração. Além disso, em enum, a instância deve ser definida primeiro e campos ou métodos não podem ser definidos antes da instância. Caso contrário, o compilador relatará um erro.
Exemplo: mostre totalmente como definir métodos comuns, métodos estáticos, métodos abstratos e métodos de construção em enumerações
public enum errorcode {ok (0) {public string getDescription () {return "bem -sucedido"; }}, Error_a (100) {public string getDescription () {return "error a"; }}, Error_b (200) {public string getDescription () {return "error b"; }}; Código INT privado; // Construtor: o construtor da enum só pode ser declarado como permissão privada ou não declarar permissão privada errorcode (int número) {// construtor this.code = número; } public int getCode () {// Código de retorno do método comum; } // Método Ordinary Public Abstract String getDescription (); // Método abstrato Public Static void Main (String args []) {// Método estático para (ErrorCode S: ErrorCode.Values ()) {System.out.println ("Code:" + s.getCode () + ", Descrição:" + s.getDescription ()); }}}Nota: O exemplo acima não é aconselhável, apenas para mostrar que a enumeração suporta a definição de vários métodos. Aqui está um exemplo simplificado
Exemplo: Definição de um tipo de enumeração de código de erro
Os resultados da execução deste exemplo e o exemplo acima são exatamente iguais.
public Enum ErrorCodeen {OK (0, "Success"), Error_a (100, "Error a"), Error_B (200, "Erro B"); Errorcodeen (número int, string description) {this.code = número; this.Description = Descrição; } Código privado int; Descrição de String Private; public int getCode () {Código de retorno; } public string getDescription () {return description; } public static void main (string args []) {// Método estático para (ErrorCodeen S: errorCodeen.values ()) {System.out.println ("code:" + s.getCode () + ", descrição:" + s.getDescription ()); }}}A enumeração pode implementar interfaces
enum pode implementar interfaces como classes gerais.
Ele também implementa a classe de enumeração do código de erro na seção anterior. Ao implementar a interface, ela pode restringir seus métodos.
interface pública inumberenum {int getCode (); String getDescription ();} public Enum ErrorCodeen2 implementa inumberenum {ok (0, "sucessão"), error_a (100, "erro a"), error_b (200, "erro b"); ErrorCodeen2 (número int, string description) {this.code = número; this.Description = Descrição; } Código privado int; Descrição de String Private; @Override public int getCode () {Return Code; } @Override public string getDescription () {return description; }}A enumeração não pode ser herdada
Enum não pode herdar outra classe e, é claro, não pode herdar outra enumeração.
Como enum são realmente herdadas da classe java.lang.Enum , e Java não suporta herança múltipla, a enum não pode herdar outras classes e, é claro, não pode herdar outra enum .
Cenários de aplicação enumerados
Organizar constantes
Antes de JDK1.5, a definição de constantes em Java era public static final TYPE a ; nesta forma. Com as enumerações, você pode organizar constantes de associações para tornar o código mais legível e seguro e também usar os métodos fornecidos pelas enumerações.
Formato da declaração de enumeração
Nota: Se não houver um método definido na enumeração, você também poderá adicionar vírgula, semicolon ou nada após a última instância.
Os três métodos de declaração a seguir são equivalentes:
Cor da enum {Red, verde, azul} color {vermelho, verde, azul,} enum cor {vermelho, verde, azul; }Máquina de estado de mudança
Frequentemente usamos declarações de switch para escrever máquinas de estado. Após o JDK7, o Switch apoiou os parâmetros de int、char、String、enum . Comparado com esses tipos de parâmetros, o código de comutação usando enumerações é mais legível.
Sinal de enumeração {vermelho, amarelo, verde} public static string getTrafficStruct (sinal de sinal) {string Instruct = "Signal Light Faids"; switch (sinal) {case Red: Instruct = "Red Light Stop"; quebrar; Case amarelo: Instruct = "Por favor, preste atenção à luz amarela"; quebrar; Case Green: Instruct = "Green Light Line"; quebrar; Padrão: quebra; } Return Instruct;}Organizar enumeração
As enumerações de tipos semelhantes podem ser organizadas através de interfaces ou classes.
No entanto, geralmente é organizado por interface.
O motivo é: a interface Java adicionará automaticamente o modificador public static ao tipo enum ao compilar; A classe Java adicionará automaticamente o modificador static ao tipo enum ao compilar. Você viu a diferença? É isso mesmo, isto é, organizar enum na classe. Se você não o modificar para public , só poderá acessá -lo neste pacote.
Exemplo: Organize Enums em interfaces
Planta de interface pública {enum implementa o inumberenum {batata (0, "batata"), tomate (0, "tomate"); Vegetal (número int, descrição da string) {this.code = número; this.Description = Descrição; } Código privado int; Descrição de String Private; @Override public int getCode () {return 0; } @Override public String getDescription () {return null; }} enum sum implementos de frutas inumerenum {Apple (0, "maçã"), laranja (0, "laranja"), banana (0, "banana"); Frutas (número int, descrição da string) {this.code = número; this.Description = Descrição; } Código privado int; Descrição de String Private; @Override public int getCode () {return 0; } @Override public String getDescription () {return null; }}}Exemplo: Organize Enums em uma classe
Este exemplo tem o mesmo efeito que o exemplo anterior.
public class Plant2 {public Enum implementos vegetais inumberenum {...} // omitir o código public Enum implementos de frutas inumberenum {...} // omitir o código}Enumeração de Estratégia
Uma enumeração de estratégia é mostrada em Java eficaz. Essa enumeração classifica as constantes enum por enumeração anumeração aninhada.
Embora essa abordagem não seja tão concisa quanto a declaração do Switch, ela é mais segura e flexível.
Exemplo: Exemplo de Enumeração de Políticas em EffectViejava
Enum Payrollday {Segunda -feira (Paytype.Weekday), terça -feira (Paytype.Weekday), quarta -feira (Paytype.Weekday), quinta -feira (Paytype.Weekday), sexta -feira (Paytype.WeekDay), sábado (Paytype.Weekend), domingo (Paytype.WeekDay); Paytype final privado Paytype; PayrollDay (Paytype Paytype) {this.PayType = PayType; } Pay Double (Double Hoursworked, Double Payrate) {Return Paytype.Pay (HourSworked, Payrate); } // Política Enum Private Enum Paytype {Weeekday {Double FourtimePay (Horas duplas, Double Payrate) {Horário de retorno <= hours_per_shift? 0: (horas - horas_per_shift) * Payrate / 2; }}, Fim de semana {duplo ex -horário (horas duplas, pagamento duplo) {Horário de retorno * Payrate / 2; }}; private estático final int hours_per_shift = 8; resumo duplo hourtimePay (HRS duplo, pagamento duplo); Pagamento duplo (duplo hora de trabalho duplo) {duplo Basepay = HourSworked * Payrate; Retornar Basepay + ExttimePay (Hoursworked, Payrate); }}}teste
System.out.println ("Ganhos para pessoas que ganham 100 por hora salar na sexta -feira por 8 horas:" + payrollday.friday.Pay (8.0, 100)); System.out.println ("ganhos para pessoas que ganham 100 por hora no sábado por 8 horas:" + folha de pagamentoEnumset e enummap
O Java fornece duas classes de ferramentas que são convenientes para a operação de enum - enumset e enummap.
EnumSet é uma implementação de um Set de alto desempenho dos tipos de enum. Requer que as constantes enumes colocadas nele sejam pertencentes ao mesmo tipo de enumeração.
EnumMap é uma implementação de mapa adaptada para tipos de enum. Embora o uso de outras implementações Map (como o hashmap) também possa concluir as instâncias do tipo enum para valorizar o mapeamento, o uso do enummap é mais eficiente: ele pode receber apenas instâncias do mesmo tipo de enumeração que os valores -chave e porque o número de instâncias do tipo enum é relativamente fixo e limitado, o enummap usa uma matriz para armazenar os valores correspondentes ao tipo enum. Isso torna o enummap muito eficiente.
// Uso do enumset System.out.println ("Display de enumset"); enumset <rorwercodeen> errset = enumset.allof (errorcodeen.class); para (ErrorCodeen E: errset) {System.out.println (e.Name () + ":" + E.ordinal ());} // Uso de enummap System.out.println ("enummap Display"); enummap <statemachine.signal, string> errmap = novo "); EnumMap(StateMachine.Signal.class);errMap.put(StateMachine.Signal.RED, "Red Light");errMap.put(StateMachine.Signal.YELLOW, "Yellow");errMap.put(StateMachine.Signal.GREEN, "Green Light");for (Iterator<Map.Entry<StateMachine.Signal, String>> iter = errmap.entryset (). iterator (); System.out.println (Entry.getKey (). Name () + ":" + Entry.getValue ());}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.