En el desarrollo real, un objeto de clase a menudo tiene varios permisos, y cada permiso tiene dos estados: Sí y No. Normalmente, cuántos campos hay para guardar el estado correspondiente. Si hay demasiados permisos, este método parece extremadamente engorroso. Recientemente, aprendí una forma de realizar la gestión de autoridad con un campo int, que es conveniente y rápida, el principio de realización es simple y la operación se simplifica enormemente. Me tomó una mañana entera estudiar y simplemente me di cuenta de la gestión de 8 permisos (De hecho, el campo int puede administrar 32 bits, y no hay una diferencia esencial con la administración de 8 bits), aquí hay un breve resumen del proceso de implementación y los principios internos
1. Conocimientos básicos para conocer el espacio que ocupan los tipos de datos básicos en JAJA:
Cuatro tipos de tipos de datos básicos de Java y ocho tipos: byte (1 byte), corto (2 bytes), int (4 bytes), largo (8 bytes), char (1 byte), booleano (1 byte), Float (4 bytes), doble (8 bytes), de los cuales 1 byte = 8 bits, por lo que el tipo int ocupa 32 bits en la memoria de la computadora
2. Conocimientos básicos para comprender los operadores de bits en JAVA, utilizados aquí & (y), | (o), ~ (no)
Operaciones simples (todos los datos binarios)
1 y 1 = 1 1 | 1 = 1 ~ 0 = 1
1 y 0 = 0 1 | 0 = 1 ~ 1 = 0
0 y 1 = 0 0 | 1 = 1
0 y 0 = 0 0 | 0 = 0
Después de comprender el conocimiento básico anterior, simplemente escriba una pequeña demostración y pruebe la conveniencia de usar la operación de bits para administrar los permisos (si los números decimales participan en las operaciones de bits, primero convierta el número decimal a binario y luego conviértalo a decimal después de que se complete la operación , Todo esto lo hace automáticamente la computadora)
public class Authority { // Agregar permisos private static final int ALLOW_INSERT = 1 << 0; // Eliminar permisos private static final int ALLOW_DELETE = 1 << 1; // Modificar permisos private static final int ALLOW_UPDATE = 1 << 2; / / Ver permisos private static final int ALLOW_SELECT = 1 << 3; // Leer permisos private static final int ALLOW_READ = 1 << 4; // Permisos de escritura private static final int ALLOW_WRITE = 1 << 5; // Copiar privilegio private static final int ALLOW_COPY = 1 << 6; // Privilegio de solo lectura private static final int ALLOW_READONLY = 1 << 7; // Se usa para guardar los permisos existentes actualmente, es decir, use este campo para guardar 8 estados de permisos private int state;
// Establecer permisos, uno o más
public void setAuto (int auto) { state = auto; } // Usar para agregar un permiso, uno o más public void addAuto (int auto) { state = state | auto; } // Usado para eliminar un permiso public void delAuto (int auto) { state = state & ~ auto; } // Se usa para verificar si hay un determinado permiso public boolean isAllow (int auto) { return ((state & auto) == auto) ; } // Se usa para verificar si no hay un permiso determinado public boolean isNotAllow (int auto) { return ((state & auto) == 0); }
}
mirada vacía estática pública (Autoridad automática) { 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));
Lo anterior es todo el código de la demostración que usa el campo int para administrar los 8 estados de permisos. El estado de estos 8 permisos es lo que comienzo al azar, no me importan estos detalles
Escriba un método de prueba para verificar
public static void main （String [] args） {
// Prueba 1: configura un objeto para que tenga 8 permisos
Autoridad auto = nueva Autoridad ();
auto.setAuto (（1 << 8） -1);
mirar (auto);
El resultado de la impresión muestra que todos los permisos son verdaderos
// Prueba dos, sobre la base de todos los permisos, elimina la adición, eliminación, modificación y verifica los permisos
auto.delAuto (ALLOW_INSERT | ALLOW_DELETE | ALLOW_UPDATE | ALLOW_SELECT);
mirar (auto);
El resultado de la impresión muestra que el permiso para agregar, eliminar, modificar y verificar es falso
// Prueba 3 Agrega el permiso de eliminación en base a la Prueba 2
auto.addAuto (ALLOW_DELETE);
mirar (auto);
El resultado de la impresión muestra que el permiso de eliminación se ha agregado correctamente.
Hasta ahora, la demostración de la función básica está completa. Un campo int puede guardar varios estados. Aquí hay una breve explicación del principio interno
1. Primero defina 8 estados, cada estado se obtiene desplazando el número de bits hacia la izquierda en el sistema binario, es decir
0000 0000 0000 0000 0000 0000 0000 0001 significa 1 << 0;
Dado que aquí se muestran 8 estados, solo se escriben 8 bits y se omiten todos los ceros anteriores.
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
No es difícil ver de lo anterior que, entre estos 8 bits, 1 representa autoridad y 0 no representa autoridad. De esta manera, cada bit controla una autoridad por separado, y la combinación de 8 bits puede realizar la gestión de 8 tipos de autoridad.
1. Establecer permisos setAuto (int auto) {
estado = auto;
}
La implementación es tal que se pasa un valor int, y un valor representa un permiso, y se puede pasar más de uno. Utilice el operador de bits "|" para conectar parámetros, como agregar y eliminar permisos
Aumente los permisos ALLOW_INSERT su forma binaria 0000 0001
Eliminar permiso ALLOW_DELETE su forma binaria 0000 0010
De acuerdo con el principio de operación de bits, dos números binarios se colocan en OR
0000 0001
| 0000 0010
0000 0011
No es difícil ver que los dos últimos permisos de adiciones y eliminaciones son ambos 1, lo que significa que actualmente hay permisos de adiciones y eliminaciones, y el resto de los permisos son todos 0, lo que significa que no hay permisos.
2. Eliminar el permiso public void delAuto (int auto) { state = state & ~ auto; }
Explicación del código: establezca el estado del estado en la negación del estado actual y el valor int cargado. Por ejemplo, actualmente existe el permiso para agregar y eliminar, y el permiso debe eliminarse.
Según el principio de operación de bits 0000 0011 & ~ 0000 0001
El primer paso ~ 0000 0001 es 1111 1110
La segunda parte 0000 0011 y 1111 1110
0000 0011
& 1111 1110
0000 0010
El resultado es 0000 0010. Se puede ver que el número en el bit de permiso agregado es 0, lo que significa que no hay ningún permiso agregado, solo el permiso de eliminación.
3. Comprueba si tienes permiso
public boolean isAllow (int auto) { return ((estado y auto) == auto); }
Suponga que actualmente tiene permiso para agregar y eliminar 0000 0011
Pase el valor int ALLOW_INSERT y su binario es 0000 0001, lo que significa ver si hay un aumento en los permisos
El valor de (0000 0011 y 0000 0001) es 0000 0001
Como se mencionó anteriormente, si se trata de una operación de bits, la computadora convertirá el número a un cálculo binario y luego convertirá el resultado a decimal
== es un operador lógico y debe convertirse a cálculo decimal
El sistema decimal de 0000 0001 es 1, y el parámetro pasado 0000 0001 también es 1, y el resultado de 1 == 1 es verdadero
Es decir, 0000 0011 ha aumentado la autoridad, y esta operación de bit también calcula otros métodos, no demostrados uno por uno.
}