No desenvolvimento real, um objeto de classe geralmente tem várias permissões, e cada permissão tem dois estados: Sim e Não. Normalmente, quantos campos existem para salvar o estado correspondente. Se houver muitas permissões, este método parece extremamente complicado. Recentemente, aprendi uma maneira de realizar o gerenciamento de autoridade com um campo int, que é conveniente e rápido, o princípio de realização é simples e a operação é muito simplificada. Demorei uma manhã inteira para estudar e simplesmente percebi o gerenciamento de 8 permissões (Na verdade, o campo int pode gerenciar 32 bits e não há diferença essencial com o gerenciamento de 8 bits), aqui está um breve resumo do processo de implementação e princípios internos
1. Conhecimento básico para conhecer o espaço ocupado por tipos de dados básicos em JAJA:
Quatro tipos de tipos de dados básicos java e oito tipos: byte (1 byte), curto (2 bytes), int (4 bytes), longo (8 bytes), char (1 byte), booleano (1 byte), Float (4 bytes), double (8 bytes), dos quais 1 byte = 8 bits, portanto o tipo int ocupa 32 bits na memória do computador
2. Conhecimento básico para entender os operadores de bits em JAVA, usado aqui & (e), | (ou), ~ (não)
Operações simples (todos os dados binários)
1 e 1 = 1 1 | 1 = 1 ~ 0 = 1
1 e 0 = 0 1 | 0 = 1 ~ 1 = 0
0 e 1 = 0 0 | 1 = 1
0 & 0 = 0 0 | 0 = 0
Depois de compreender o conhecimento básico acima, basta escrever uma pequena demonstração e tentar a conveniência de usar a operação de bits para gerenciar as permissões (se os números decimais participarem das operações de bits, primeiro converta o número decimal em binário e depois converta em decimal após a conclusão da operação , Tudo isso é feito automaticamente pelo computador)
public class Authority { // Adicionar permissões private static final int ALLOW_INSERT = 1 << 0; // Excluir permissões private static final int ALLOW_DELETE = 1 << 1; // Modificar permissões private static final int ALLOW_UPDATE = 1 << 2; / / Ver permissões privado estático final int ALLOW_SELECT = 1 << 3; // Permissões de leitura privado estático final int ALLOW_READ = 1 << 4; // Permissões graváveis privado estático final int ALLOW_WRITE = 1 << 5; // Copiar privilégio privado estático final int ALLOW_COPY = 1 << 6; // Privilégio somente leitura privado estático final int ALLOW_READONLY = 1 << 7; // Usado para salvar as permissões existentes atualmente, ou seja, use este campo para salvar 8 estados de permissão private int state;
// Definir permissões, uma ou mais
public void setAuto (int auto) { state = auto; } // Use para adicionar uma permissão, uma ou mais public void addAuto (int auto) { state = state | auto; } // Usado para deletar uma permissão public void delAuto (int auto) { state = state & ~ auto; } // Usado para verificar se há uma certa permissão public boolean isAllow (int auto) { return ((state & auto) == auto) ; } // Usado para verificar se não há uma permissão certa public boolean isNotAllow (int auto) { return ((state & auto) == 0); }
}
public static void look (Authority auto) { System.out.println ("ALLOW_INSERT 有 权限 ：" + auto.isAllow (ALLOW_INSERT)); System.out.println ("ALLOW_DELETE 有 权限 ：" + auto.isAllow (ALLOW_DELETE)); System.out.println ("ALLOW_UPDATE 有 权限 ：" + auto.isAllow (ALLOW_UPDATE)); System.out.println ("ALLOW_SELECT 有 权限 ：" + auto.isAllow (ALLOW_SELECT)); System.out.println ("ALLOW_READ 有 权限 ：" + auto.isAllow (ALLOW_READ)); System.out.println ("ALLOW_WRITE 有 权限 ：" + auto.isAllow (ALLOW_WRITE)); System.out.println ("ALLOW_COPY 有 权限 ：" + auto.isAllow (ALLOW_COPY)); System.out.println ("ALLOW_READONLY 有 权限 ：" + auto.isAllow (ALLOW_READONLY));
Acima está todo o código da demonstração que usa o campo int para gerenciar os 8 status de permissão. O status dessas 8 permissões é o que eu começo aleatoriamente, não me importo com esses detalhes
Escreva um método de teste para verificar
public static void main （String [] args） {
// Teste 1: Defina um objeto para ter 8 permissões
Autoridade auto = nova Autoridade ();
auto.setAuto (（1 << 8） -1);
olhar (automático);
O resultado da impressão mostra que todas as permissões são verdadeiras
// Teste dois, com base em todas as permissões, exclua a adição, exclusão, modificação e verifique as permissões
auto.delAuto (ALLOW_INSERT | ALLOW_DELETE | ALLOW_UPDATE | ALLOW_SELECT);
olhar (automático);
O resultado da impressão mostra que a permissão para adicionar, excluir, modificar e verificar é falsa
// Teste 3 Adicionar permissão de exclusão com base no Teste 2
auto.addAuto (ALLOW_DELETE);
olhar (automático);
O resultado da impressão mostra que a permissão de exclusão foi adicionada com sucesso
Até agora, a demonstração da função básica está completa. Um campo int pode salvar vários estados. Aqui está uma breve explicação do princípio interno
1. Primeiro defina 8 estados, cada estado é obtido deslocando o número de bits para a esquerda no sistema binário, a saber
0000 0000 0000 0000 0000 0000 0000 0001 significa 1 << 0;
Como 8 estados são demonstrados aqui, apenas 8 bits são gravados e todos os 0s anteriores são omitidos.
0000 0001 1 << 0 ALLOW_INSERT
0000 0010 1 << 1 ALLOW_DELETE
0000 0100 1 << 2 ALLOW_UPDATE
0000 1000 1 << 3 ALLOW_SELECT
0001 0000 1 << 4 ALLOW_READ
0010 0000 1 << 5 ALLOW_WRITE
0100 0000 1 << 6 ALLOW_COPY
1000 0000 1 << 7 ALLOW_READONLY
Não é difícil perceber pelo exposto que, entre esses 8 bits, 1 representa autoridade e 0 não representa autoridade. Desta forma, cada bit controla uma autoridade separadamente, e a combinação de 8 bits pode realizar o gerenciamento de 8 tipos de autoridade.
1. Defina as permissões setAuto (int auto) {
estado = automático;
}
A implementação é tal que um valor int é transmitido e um valor representa uma permissão e mais de uma pode ser transmitida. Use o operador de bit "|" para conectar parâmetros, como adicionar e excluir permissões
Aumente as permissões ALLOW_INSERT sua forma binária 0000 0001
Excluir permissão ALLOW_DELETE sua forma binária 0000 0010
De acordo com o princípio da operação de bit, dois números binários são combinados
0000 0001
| 0000 0010
0000 0011
Não é difícil ver que as duas últimas permissões de adições e exclusões são 1, o que significa que existem atualmente permissões de adições e exclusões, e o restante das permissões são todas 0, o que significa nenhuma permissão.
2. Excluir permissão public void delAuto (int auto) { state = state & ~ auto; }
Explicação do código: defina o estado de estado para a negação do estado atual e o valor int carregado. Por exemplo, atualmente existe a permissão para adicionar e excluir, e a permissão precisa ser excluída.
De acordo com o princípio de operação de bit 0000 0011 e ~ 0000 0001
A primeira etapa ~ 0000 0001 é 1111 1110
A segunda parte 0000 0011 e 1111 1110
0000 0011
E 1111 1110
0000 0010
O resultado é 0000 0010. Pode-se ver que o número no bit de permissão adicionada é 0, o que significa que não há permissão adicionada, apenas a permissão de exclusão
3. Verifique se você tem permissão
public boolean isAllow (int auto) { return ((state & auto) == auto); }
Suponha que você tenha atualmente permissão para adicionar e excluir 0000 0011
Passe o valor int ALLOW_INSERT e seu binário é 0000 0001, o que significa ver se há um aumento nas permissões
O valor de (0000 0011 e 0000 0001) é 0000 0001
Conforme mencionado acima, se for uma operação de bit, o computador irá converter o número para cálculo binário e, em seguida, converter o resultado para decimal
== é um operador lógico e precisa ser convertido para cálculo decimal
O sistema decimal de 0000 0001 é 1, e o parâmetro passado 0000 0001 também é 1, e o resultado de 1 == 1 é verdadeiro
Ou seja, 0000 0011 aumentou a autoridade e outros métodos também são calculados por esta operação de bit, não demonstrados um por um
}