Sobre enumeração
A maioria dos enumes escritos nos locais recebe uma enumeração e, em seguida, o exemplo começa a alternar. Mas quero dizer que é improvável que os dados do meu código sejam enumes, geralmente strings ou números. Por exemplo, depois de analisar um SQL, primeiro determino o tipo SQL. Ao interceptar o token SQL, a interceptação pode ser selecionada, excluir, atualizar, inserir, alterar etc., mas todas são strings. Neste momento, quero usar enums, mas não posso fazê -lo. Como converter a string em uma enumeração? Situações semelhantes incluem retirar dados do banco de dados e fazer julgamentos com base em alguns tipos, passar dados da página e realizar operações diferentes de acordo com diferentes tipos, mas são todas strings, não enumes. A tragédia é que raramente vejo alguém escrevendo essa coisa; Então, eu escrevi, esperando que alguém possa usá -lo.
Primeiro de tudo, por que usar enumeração? Quando é melhor usar enums? Quais são as vantagens de usar enums?
Eu acho que quando você está em algumas classes de categoria e pode enumerar e inalterados tipos para orientar o programa para rotear para diferentes lugares, usar enumeração é uma escolha melhor;
Parece um pouco confuso, mas há um exemplo que pode ser entendido, por exemplo:
Podemos listar as coisas que fazemos em nossos dias de trabalho diário:
Vá trabalhar, fazer reuniões, comer, dormir, etc.
Podemos listar as peças que precisam ser examinadas pelo Departamento do ANT do hospital:
Olhos, nariz, orelhas, boca, etc.
Estes podem ser enumerados, e temos que fazer cada um deles de uma maneira diferente;
Claro que você pode dizer:
1. Pode ser despachado dinamicamente através de arquivos de configuração ou anotação;
2. As constantes podem ser usadas para obter efeitos semelhantes;
3. Expresse -o diretamente através dos iguais da string e expresse
Se você usar o método de adição de configuração para enviá -lo, ele será flexível e fácil de modificar; Mas se usarmos muitos parâmetros que não são modificados com frequência, geralmente aumentamos o ônus da configuração e, quando você precisa ler a lógica do sistema, precisará ler a configuração e o código novamente; No entanto, se os parâmetros forem informações dinamicamente transformáveis, o uso da configuração é a escolha correta;
O uso de constantes geralmente é números ao alternar os casos, e as strings não podem ser alteradas em casos em Java. O objetivo do uso de constantes aumenta a legibilidade que o caso 1 e o caso 2 ... mas os dados da string também são problemáticos. A menos que seja mapeado novamente, não há necessidade. De fato, a enumeração é quase mapeada para você uma vez, mas apenas encapsula o código. Como foi feito e suportado sintaticamente, por que não usá -lo! Em segundo lugar, embora as constantes aumentem a legibilidade, elas não têm o conceito de categorias e tipos de gerenciamento. Ou seja, uma definição de enum define uma categoria, que pode listar as coisas necessárias para esse intervalo bem. As constantes geralmente são alguns pools definidos por si mesmos, colocados em algumas classes públicos ou definidos aleatoriamente e são relativamente dispersos. Além disso, a enumeração é claramente definida ao alternar e o gabinete está dentro do intervalo da enumeração de bloqueio. Ele pode não apenas controlar o sistema, aumentar a legibilidade, mas também verificar quais informações de enumes nesta categoria são a qualquer momento, de modo a alcançar a função de analisar os arquivos de configuração; Mas ainda retorna nessa frase, se os parâmetros forem variáveis, não será adequado para enumeração. As enumerações devem ser enumeráveis ou as considerações atuais do sistema podem ser enumeradas. Por exemplo, pode haver muitos hospitais no hospital acima, mas o hospital atual processa apenas algumas partes e não processa outras. Este é o motivo. O que é variável? Por exemplo, os parâmetros da URL são despachados para o método correspondente. É impossível para todos adicionar uma lógica e adicionar um enumerador e um gabinete. No momento, é melhor usar [Configuration + Dynamic Method Dispatch]. Obviamente, a configuração pode ser apenas um arquivo ou anotação.
O mais rústico é usar a string igual para implementá -la com se o caso. Haha, não há nada de errado com isso, mas isso é escrito de uma maneira dispersa. Em segundo lugar, cada correspondência igual a ser comparada a cada caractere toda vez que você corresponde aos iguais. Se você fazer muito no seu código, o desempenho não será muito bom e o restante ficará mais claro depois de olhar para a descrição acima;
Em segundo lugar, a enumeração fornece um componente de gerenciamento de tipos, tornando o sistema orientado a objetos mais perfeito, para que alguns tipos de gerenciamento possam ser configurados e gerenciados. Onde a enumeração é usada, você pode encontrar a definição de enumeração que foi processada e não foi processada, e o acima é difícil de alcançar; Por exemplo, existem 10 tipos de tipos de operação definidos nos bancos de dados; portanto, no processo de determinação, a enumeração pode ser visualizada como um arquivo de configuração e é muito simples de gerenciar.
Finalmente, a enumeração é absolutamente singleton, e o desempenho da comparação é comparável ao do desempenho digital, que pode obter legibilidade e desempenho.
Uso básico do tipo Enum
Com uma base tão teórica, vamos dar uma olhada nos tipos de enum em Java:
1. Você pode adicionar variáveis e métodos para enum
Vamos dar uma olhada em um exemplo de código:
Public Enum State {Normal ("Normal", 1), Atualização ("Atualizado", 2), Excluído ("Excluído", 3), disparado ("Mascarado", 4); // Nome da sequência privada variável do membro; índice privado int; // Método de construção, Nota: O construtor não pode ser público, porque a enum não pode ser instanciada em estado privado (nome da string, int index) {this.name = name; this.index = index; } // método normal public static string getName (int index) {for (estado c: estado .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; }}A partir do código acima, podemos ver que, depois de definir o valor da enumeração e adicionar um ponto e vírgula e, em seguida, você pode definir outras variáveis e métodos. Deve -se notar, em particular, que o método de construção em enum não pode ser identificado por público; portanto, isso é feito para impedir que o usuário instancie a enumeração.
2. Pode ser usado para definir constantes
Vamos primeiro revisar como definir constantes em Java e ver o seguinte código:
public static final int normalState = 1; private estático final int updatestate = 2;
Abaixo, também podemos usar enum enum para substituir a definição constante acima, o código é o seguinte:
Public Enum State {Normal, Atualizar, Excluído, Demitido}Não há vantagem de sintaxe no uso da enum para definir constantes em Java, mas o tipo Enum enum pode fornecer mais funções operacionais.
3. Implementar interface em enum
Vamos primeiro olhar para o seguinte código:
interface pública icanreadState {void read (); String getState ();} public Enum State implementa o icanReadState {Normal ("Normal", 1), Atualização ("Atualizado", 2), excluído ("Excluído", 3), disparado ("Masked", 4); nome de string privado; índice privado int; estado privado (nome da string, int index) {this.name = name; this.index = index; } // Método da interface 1 @Override public String getState () {return this.name; } // Método da interface 2 @Override public void read () {System.out.println (this.index + ":" + this.name); }}Assim como o uso de interfaces nas classes gerais, o enum enum também pode herdar a interface e implementar todos os métodos na interface. A vantagem disso é que ele pode classificar mais convenientemente, comparar e outras operações sobre os valores na enumeração e ter melhor encapsulamento.
Exemplo
Vamos primeiro definir uma enumeração simples (aqui está apenas um exemplo, então simplesmente definiremos 3 variáveis):
public enum sqltypeenum {inserir, atualizar, excluir, selecionar}Depois de analisar o SQL, é obtido um token. Como obtemos a enumeração desse token?
Pegue assim:
String token = "select"; sqltypeenum sqltypeenum = sqltypeenum.valueof (token.toUppercase ());
Se não forem obtidos, Java lançará uma exceção: ilegalargumentException no enum const classe sqltypeenum.xxx
A razão pela qual faço a capitalização é porque as enumes também são capitalizadas (é claro, se a sua enumeração estiver em minúsculas, você será minúsculo, mas é mais problemático misturá -lo). De fato, Valueof chama o mapeamento subjacente da enumeração:
Este método será chamado ao ligar:
Portanto, há também um hashmap lá dentro, haha!
Depois de obter essas informações, você pode fazer a operação desejada:
switch (sqltypeenum) {case insert: manipula a lógica Inserir; quebrar; Excluir casos: manipular a lógica excluir; quebrar; ....}OK, às vezes podemos não querer usar strings como inserção ou atualização diretamente na interação, porque muitas vezes são necessárias as especificações de nomeação;
Por exemplo, defina alguns tipos de ação do usuário:
1. Salvar informações do usuário
2. Obtenha as informações básicas do usuário através do ID
3. Obtenha a lista de usuários
4. Exclua as informações do usuário por meio de ID
etc.
Podemos definir enumerações como:
public enum userOptionenum {Save_User, get_user_by_id, get_user_list, delete_user_by_id}No entanto, os métodos do sistema e algumas configurações de palavras -chave são geralmente escritas como:
saveuser, getUserById, getUserById, deleteUserById
Obviamente, cada um tem suas próprias regras, mas se você não quiser fazer o mapeamento no meio, apenas se compromete com isso. Substitua todos os nomes de enum, que parecem bastante estranhos ou substitua todos os nomes de métodos, que são ainda mais estranhos, ou você pode fazer o mapeamento. OK, é um pouco mais problemático, mas na verdade não é problemático?
Vamos escrever primeiro um método para converter dados de estilo sublinhado enumerado em camelos e colocá-los em um Stringutils:
public static string convertdbstyletojavastyle (string dbstylestring, boolean firstupper) {dbstylestring = dbstylestring.TolowerCase (); String [] tokens = dbstylestring.split ("_"); StringBuilder StringBuilder = new StringBuilder (128); int length = 0; para (string token: tokens) {if (stringutils.isnotblank (token)) {if (length == 0 &&! FirstUper) {stringbuilder.append (token); } else {char c = token.charat (0); if (c> = 'a' || c <= 'z') c = (char) (c - 32); stringbuilder.append (c); stringbuilder.append (token.substring (1)); }} ++ comprimento; } return stringbuilder.toString (); }Sobrecarregar um método:
public static string convertdbstyletojavalocalStyle (string dbstylestring) {return convertdbstyletojavastyle (dbstylestring, false); }Em seguida, defina a enumeração:
public enum userOptionenum {save_user, get_user_by_id, get_user_list, delete_user_by_id; mapa estático final privado <string, userOptionenum> enum_map = new hashmap <string, userOptionenum> (64); static {for (userOptionenum v: valores ()) {enum_map.put (v.toString (), v); }} public staticUserOptionenum fromString (String v) {userOptionenum userOptionenum = enum_map.get (v); return userOptionEnum == NULL? Padrão: userOptionenum; } public string tostring () {string stringValue = super.toString (); return stringutil.convertdbstyletojavalocalstyle (stringValue); }}OK, passe um parâmetro de evento como este para que, se for: saveUser, use:
String event = "saveUser"; // se você obtiver o parâmetro userOptionenum enum = userOptionenum.FromString (event);
Na verdade, eu mesmo fiz um hashmap e adicionei uma destramento porque existem algumas restrições à enumeração e alguns métodos não permitem que você substitua, como o método ValueOf.
Na verdade, não há nada a dizer. Vamos falar sobre a adição de algumas variáveis personalizadas às enumes. De fato, exceto por ser um singleton, os outros enumes são semelhantes às classes comuns. Eles também podem ter métodos construtores, mas não por padrão. Eles também podem fornecer variáveis personalizadas e, em seguida, obter métodos definidos e obtidos. No entanto, se estiver definido, o thread não será seguro, portanto, preste atenção a esse ponto; Portanto, o método de construção é geralmente escrito:
public enum sqltypeenum {insert ("insert in"), exclua ("exclua de") ...... omitido; Nome da String Private; // Defina variável personalizada private SQLTYPEENUM (Nome da String) {this.name = Name; } public string getName () {return name; } public string tostring () {return name + "i Dash"; // reescreva o método da tostragem} // geralmente não recomendado public void setName (nome da string) {this.name = name; }}Chamado:
Sqltypeenum sqltypeenum = sqltypeenum.valueof ("insert"); system.out.println (sqltypeenum); system.out.println (sqltypeenum.getName ());Não é recomendável chamá -lo:
sqltypeenum.setName ("maldito");Em outro tópico:
Sqltypeenum sqltypeenum = sqltypeenum.valueof ("insert"); system.out.println (sqltypeenum); system.out.println (sqltypeenum.getName ());Descobri que o resultado foi alterado, haha!