Notas de reflexión para principiantes

Reflexión notas para principiantes

El concepto

El mecanismo de reflexión (reflexión) JAVA significa que en el estado de ejecución del programa, puede construir un objeto de cualquier clase, puede comprender la clase a la que pertenece cualquier objeto, puede comprender las variables miembro y los métodos de cualquier clase, puede llamar a las propiedades de cualquier objeto和 方法。 Y métodos. Esta función de adquirir dinámicamente información del programa y llamar dinámicamente objetos se denomina mecanismo de reflexión del lenguaje Java. La reflexión se considera la clave del lenguaje dinámico.

Clase de persona en el caso

	public class Person {
		private String name;
		private int age;
		public Person() {
			super();

		}
		public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	public void eat() {
		System.out.println("今天吃了一顿金钱豹");
	}
	private void eat(String name) {
			System.out.println("吃了" + name);
	}
	public void eat(int num) {
		System.out.println("今天吃了" + num + "顿金钱豹");
	}
}

Obtener el objeto bytecode

1. Usa classpath para obtener

   Class clazz = Class.forName("com.pretext.reflect.Person");
   

2. Obtener usando el nombre de la clase

   Class clazz2 = Person.class;
   

3. Usar adquisición de objetos

   Person person = new Person();
   Class clazz3 = person.getClass();
   

   Tres objetos de código de bytes pertenecen al mismo objeto.

Crear objetos de instancia a través de bytecode

1. Use el método newInstance () para llamar a la construcción sin parámetros para crear el objeto

           Class aClass = Class.forName("com.pretext.reflect.Person");
           Person p = (Person) aClass.newInstance();
   

   Equivalente a la persona p = new Persona ();

2. Utilice el constructor para llamar al método de construcción parametrizado para crear el objeto.

           Class clazz = Class.forName("com.pretext.reflect.Person");
           Constructor constructor = clazz.getConstructor(String.class, int.class);
           Person person = (Person) constructor.newInstance("zhang", 23);
   

   Equivalente a Persona p = nueva Persona ("zhang", 23);

Cambiar el valor de un atributo a través de la reflexión

• ParapúblicoPropiedades, use Class.getField (String) para obtener el campo especificado en la clase

          Class aClass = Class.forName("com.pretext.reflect.Person");
          Constructor constructor = aClass.getConstructor(String.class, int.class);
          Person person = (Person) constructor.newInstance("zhang", 23);
          Field name = aClass.getField("name");
  

  Debido a que el atributo de nombre de la clase Persona utilizada en el programa es privado, el programa informará después de ejecutarseNoSuchFieldException

• ParaprivadoPropiedades, use el método getDeclaredField () para obtener el objeto Field

          Class aClass = Class.forName("com.pretext.reflect.Person");
          Constructor constructor = aClass.getConstructor(String.class, int.class);
          Person person = (Person) constructor.newInstance("zhang", 23);
          // Field name = aClass.getField("name");
          // System.out.println(name.toString());
          // name.set(person, "lisi");
          Field field = aClass.getDeclaredField("name");
          field.setAccessible(true);
          field.set(person, "lisi");
          System.out.println(person);
   
  

  Antes de configurar, debe usar == field.setAccessible (true); == establecer permisos de acceso, de lo contrario, informaráIllegalAccessException

Ejecutar métodos en la clase a través de la reflexión.

Similar a obtener el objeto Field

• Para métodos públicos, use getMethod () directamente

           Class aClass = Class.forName("com.pretext.reflect.Person");
           Constructor constructor = aClass.getConstructor(String.class, int.class);
           Person person = (Person) constructor.newInstance("zhang", 23);
           Method method = aClass.getMethod("eat");
           method.invoke(person);
  

• Para métodos privados, use getDeclaredMethod ()

  		Class aClass = Class.forName("com.pretext.reflect.Person");
          Constructor constructor = aClass.getConstructor(String.class, int.class);
          Person person = (Person) constructor.newInstance("zhang", 23);
          Method method = aClass.getMethod("eat");
          method.invoke(person);
          Method method1 = aClass.getMethod("eat", int.class);
          method1.invoke(person, 10);
          Method method2 = aClass.getDeclaredMethod("eat", String.class);
          method2.setAccessible(true);
          method2.invoke(person, "狗肉");
  

  No olvidessetAccessible (verdadero);

El nombre del método contiene el método declarado para acceder a la propiedad privada o método