La reflexión es una característica importante del lenguaje Java. Sabemos que antes de usar una clase, a menudo ya la hemos creado, como crear un archivo de clase y luego escribir algunos atributos, métodos, etc., es decir, este tipo de clase. Es estático, pero el mecanismo de reflexión te permite crear una clase dinámicamente. Además de crear una clase dinámicamente, también podemos obtener dinámicamente datos de objetos similares y asignar estos datos a la clase recién creada, lo cual es algo similar a la clonación. Muchas veces, necesitamos esta característica de crear clases dinámicamente, por ejemplo, cuando procesamos algunos negocios, pero estos negocios son ligeramente diferentes y a menudo corresponden a varias clases. Al procesar, tenemos que basarnos en diferentes procesamientos comerciales para llamar a diferentes clases. Esta vez el mecanismo de reflexión resulta útil.
La siguiente es la descripción del paquete java.lang.reflect en la API JDK:
Proporciona clases e interfaces para obtener información reflejada sobre clases y objetos. Dentro de las restricciones de seguridad, la reflexión permite el acceso programático a información sobre los campos, métodos y constructores de una clase cargada, y permite el uso de campos, métodos y constructores reflejados para operar en equivalentes subyacentes de un objeto.
AccessibleObject permite suprimir las comprobaciones de acceso si el ReflectPermission requerido está disponible.
Las matrices proporcionan métodos estáticos para crear y acceder dinámicamente a matrices.
Las clases de este paquete, así como java.lang.Class, se pueden adaptar a las necesidades de aplicaciones como depuradores, intérpretes, inspectores de objetos, navegadores de clases y servicios (como serialización de objetos y JavaBeans) que necesitan acceder al destino. objetos basados en miembros públicos de su clase de tiempo de ejecución) o miembros declarados por una clase determinada).
A continuación se utilizan dos ejemplos simples para ilustrar el uso de la reflexión. Primero, cree una clase Persona:
Copie el código de código de la siguiente manera:
prueba de paquete;
Persona de clase pública {
edad privada;
nombre de cadena privada = "";
cadena privada [] arr = nueva cadena [2];
Persona pública(){}
Persona pública (nombre de cadena, edad int) {
this.nombre = nombre;
this.age = edad;
}
público int getAge() {
edad de retorno;
}
setAge público vacío (int edad) {
this.age = edad;
}
cadena pública getName() {
nombre de retorno;
}
setName público vacío (nombre de cadena) {
this.nombre = nombre;
}
Cadena pública[] getArr() {
volver llegar;
}
setArr público vacío (cadena [] arr) {
this.arr = arr;
}
}
Ejemplo 1: obtenga los atributos y la información del método de la clase Persona. Copie el código de la siguiente manera:
prueba de vacío estático privadoSimpleReflect(){
String className = "prueba.Persona";
intentar {
Clase c = Class.forName(className);
Campo[] campos = c.getDeclaredFields();
Método[] m = c.getDeclaredMethods();
para (campo campo: campos){
System.out.println(field.getName());
}
para (Método método: m){
System.out.println(m.getClass());
}
} captura (ClassNotFoundException e) {
e.printStackTrace();
}
}
Esto es muy simple. Puede obtener una clase a través de la ruta del paquete donde se encuentra la clase. En el trabajo real, también es la más utilizada.
Ejemplo 2: Copia de objeto Copiar código El código es el siguiente:
@SuppressWarnings("sin marcar")
La copia de objeto estática pública (objeto objeto) lanza una excepción {
// Obtener el tipo de objeto
Clase classType = object.getClass();
System.out.println("" + classType.getName()); // Crea un nuevo objeto mediante el método de construcción predeterminado.
Objeto objectCopy = classType.getConstructor(nueva Clase[] {})
.newInstance(new Object[] {}); // Obtiene todas las propiedades del objeto.
Campos de campo[] = classType.getDeclaredFields();
for (int i = 0; i < campos.longitud; i++) {
Campo campo = campos[i];
Cadena nombre del campo = campo.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase() // Obtiene el nombre del método getXXX() correspondiente al atributo.
String getMethodName = "get" + firstLetter + fieldName.substring(1); // Obtiene el nombre del método setXXX() correspondiente al atributo.
String setMethodName = "set" + firstLetter + fieldName.substring(1); // Obtiene el método getXXX() correspondiente al atributo;
Método getMethod = classType.getMethod(getMethodName,
new Class[] {}); // Obtiene el método setXXX() correspondiente al atributo
Método setMethod = classType.getMethod(setMethodName,
new Class[] { field.getType() }); // Llama al método getXXX() del objeto original.
Valor del objeto = getMethod.invoke(objeto, nuevo Objeto[] {});
System.out.println(fieldName + ":" + valor // Llama al método setXXX() del objeto copiado);
setMethod.invoke(objectCopy, nuevo objeto[] {valor});
}
devolver objetoCopia;
}
Al usar la reflexión para copiar objetos, generalmente no tenemos que hacerlo nosotros mismos, porque el sistema de código abierto BeanUtils ya ha encapsulado la copia del objeto para nosotros. Podemos simplemente llamar a su método directamente, pero vale la pena señalar que BeanUtils también se basa. sobre el mecanismo de reflexión.
Aquí hay una llamada:
Copie el código de código de la siguiente manera:
principal vacío estático público (String [] argumentos) {
Persona persona = nueva Persona("tom",22);
Cadena[] cadenas = nueva Cadena[]{"a","b"};
persona.setArr(cadenas);
intentar {
Persona p = (Persona)copia(persona);
System.out.println(p.getName()+">>"+p.getAge());
para (cadena cadena: p.getArr()){
System.out.println(cadena);
}
} captura (Excepción e) {
e.printStackTrace();
}
// pruebaSimpleReflect();
}