reflexión
Reflexión (reflexión) es una de las características del lenguaje de programación Java, que permite a los programas Java que se ejecuta en la propia inspección, o "auto-examen", también llamado "introspección". La reflexión es muy potente, puede incluso dirigir los procedimientos operativos de la propiedad privada. Tenemos que aprender frente a un concepto, sólo se puede acceder clase privada interior y exterior no es suficiente, pero esta disposición se refleja flagrante roto.
Como una reflexión de espejo, se puede obtener toda la información en una clase de tiempo de ejecución se puede definir obtener cualquier información (incluyendo variables miembro, miembros del método, configuración, etc.), y puede ser campos manipulados de clase, métodos y otros constructores sección.
¿Por qué la reflexión:
Nuestra buena nueva de usuario (); no es muy bueno, ¿por qué ir a crear objetos reflejándola? Entonces quiero hacerle una pregunta, ¿por qué quieres ir a un restaurante? Por ejemplo: Comemos una cena de bistec, si nosotros mismos creado, lo que ha tenido que gestionar.
El beneficio es lo que hago cada paso es muy clara, la desventaja es lo que tenía que lograr su propia, que no se agota. tubo de suministro de ganado que, come lo que el tubo, que masacre tubo, tubo de transporte que, usted tubo de refrigeración, cocinar sus tubos y que sirve. Tome la cocción, se puede tener un chef para hacer el bien?
¿Cómo hacerlo? Hay un dicho que bueno, lo profesional para hacer gente profesional, manteniendo a los agricultores, masacre al verdugo, cocinar con el chef. Entonces estamos haciendo?
Tomamos las piernas cruzadas directas a comer lo suficiente. Además, el hotel poner las cosas bien, no tirado en el suelo, recogemos el comer, eso no es todo a lo primitivo. ¿Cómo hacerlo? Muy simple de hacer las cosas en un contenedor de la misma, tales como la carne en un plato.
En el mundo desarrollado, la primavera es la organización profesional que nos ayuda a crear un objeto, el objeto gestionado. No somos nuevos objetos, se puede obtener directamente de los granos de la primavera contenedores apropiados. Los frijoles de fondo es en realidad un Map <String, Object>, para llegar finalmente a través de getBean ( "usuario"). Este núcleo de lograr es utilizar la tecnología reflectante.
Un resumen, no una clase que se cree es su colega o dirigir una empresa de terceros, entonces usted quiere o tiene que llamar a la funcionalidad subyacente de esta clase, se necesita la tecnología reflectante. Un poco abstracto, no se preocupe, que tiene por qué ser el caso, inmediatamente clara.
reflector objeto de clase Clase
- ( "Tipo de ruta completa") el Class.forName;
- nombre de la clase .class
- Objeto .getClass ();
método común
- Obtiene el nombre del paquete, nombres de clases
- getPackage (). getName () //包名
- getSimpleName () //类名
- getName () // nombre de la clase completa
! ! Miembro de la información de definición de variables
- getFields () las variables // Obtener todas las variables miembro públicas, incluyendo heredada
- getDeclaredFields () // obtener esta definición de clase de variables miembro, incluidas las privadas, no incluye las variables heredadas
- getField (nombre variable)
- getDeclaredField (nombre variable)
! ! información de definición del constructor
- getConstructor (lista tipo de parámetro) // dan a conocer obtiene constructor
- getConstructors () // obtener todos los constructores dan a conocer
- getDeclaredConstructors () // obtener todos los métodos de construcción, incluyendo privada
- getDeclaredConstructor (int.class, String.class)
información de definición del método
- getMethods () método // obtener todos los métodos visibles, incluyendo heredó
- getMethod (nombre del método, lista tipo de parámetro)
- getDeclaredMethods () // Cómo obtener la definición de clase, incluyendo privada, no incluyen métodos heredados
- getDeclaredMethod (nombre del método, int.class, String.class)
Ejemplos de nueva reflexión
- la newInstance (); // constructor sin argumentos realizados
- la newInstance (6, "ABC".); // parámetros de configuración han realizado
- getConstructor (int.class, String.class); parámetro constructor que contiene // realizar la configuración, obteniendo
Llamar a una variable miembro de la reflexión
- getDeclaredField (nombre variable); // obtener las variables
- setAccessible (true); // permitir el acceso a los miembros privados
- conjunto (ejemplo, valor); // variable de asignación instancia especificada, una variable estática, un primer parámetro a NULL
- obtener (Ejemplo); valor de un accesible ejemplo // especificado variables, una variable estática, un primer parámetro a NULL
Reflexión llamada al método miembro
- método de adquisición
- Método m = c.getDeclaredMethod (nombre del método, el parámetro de lista de tipos);
- m.setAccessible (true); // hacen métodos privados permiten a llamarse
- m.invoke (ejemplo, los datos de parámetros); // crea un ejemplo del método especificado para realizar la
Aplicación reflejada
Crear una clase
class Student{
String name="jack";
int age=20;
public Student() {
System.out.println("无参构造");
}
public Student(String name) {
this.name=name;
System.out.println("含参构造"+name);
}
public void show(int a) {
System.out.println("show()..."+a);
}
}
Obtener un objeto de clase
private static void method() throws Exception {
Class clazz = Student.class;
Class<?> clazz2 = Class.forName("seday15.Student");
Class clazz3 = new Student().getClass();
System.out.println(clazz.getName());
System.out.println(clazz2.getName());
System.out.println(clazz3.getName());
}
La obtención de método de construcción
private static void method3(Class clazz) {
Constructor[] cs = clazz.getDeclaredConstructors();
for (Constructor c : cs) {
String name = clazz.getSimpleName();
System.out.println(name);
Class[] cs2 = c.getParameterTypes();//参数
System.out.println(Arrays.toString(cs2));
}
}
La adquisición de método miembro
private static void method4(Class clazz) {
Method[] ms = clazz.getMethods();
for (Method m : ms) {
String name = m.getName();
System.out.println(name);
Class<?>[] cs = m.getParameterTypes();
System.out.println(Arrays.toString(cs));
}
}
La adquisición de las variables miembro
private static void method2(Class clazz) {
Field[] fs = clazz.getFields();//获取public的属性
for (Field f : fs) {
String name = f.getName();
String tname = f.getType().getSimpleName();
System.out.println(name);
System.out.println(tname);
}
}
Hablemos de la violencia refleja lo que es la violencia que refleja? Hay muchos métodos de objetos Java y por motivos de seguridad, se encapsula en la clase. A menudo, estos métodos y objetos de propiedad sólo pueden ser invocados dentro de la clase, fuera de clase para ello, están ocultos, invisibles. Con el fin de obtener estos objetos y método propio de operar la clase externa, que puede ser implementado utilizando de manera violenta reflexión. En términos simples, se refiere a la propiedad privada puede ser o un programa de método, la violencia para obtener recursos a través de la tecnología de la reflexión.
La creación de la clase Person
class Person{
private String name="jack";
private int age = 30;
private void show(int[] a) {
System.out.println("show()..."+Arrays.toString(a));
}
private void test() {
System.out.println("test()...");
}
}
Mira el ejemplo anterior, las variables miembro y métodos miembros son privadas, por lo que ¿cómo vamos a obtener el valor de la misma? Vamos a prueba
package seday16new;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectPerson {
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("seday16new.Person");
// method(clazz);//隐私属性
method2(clazz);//执行方法
}
private static void method2(Class<?> clazz) throws Exception {
Method m = clazz.getDeclaredMethod("show", int[].class);
Object obj = clazz.newInstance();
m.setAccessible(true);//方法隐私可见
m.invoke(obj, new int[]{1,2,3});//执行
}
private static void method(Class clazz) throws Exception {
Field f = clazz.getDeclaredField("name");
System.out.println(f.getType().getName());
f.setAccessible(true);//属性隐私可见
Object obj = clazz.newInstance();
// f.set(obj, "rose");//设置值
System.out.println(f.get(obj));//获取值
//---所有属性
Field[] fs = clazz.getDeclaredFields();
for (Field ff : fs) {
System.out.println(ff);
ff.setAccessible(true);//暴力反射
System.out.println(ff.get(obj));
}
}
}
resultados:
- Obtener y modificar el valor de la propiedad privada
- Adquisición e implementación de métodos privados
