1. ¿Qué es la reflexión?
Una clase tiene múltiples componentes, como variables de miembros, métodos, constructores, etc.
La reflexión es cargar la clase y diseccionar los diversos componentes de la clase.
2. Cargando la clase
Hay una clase de clase en Java que representa el código de byte de una determinada clase.
Dado que la clase de clase representa el código de byting de una determinada clase, debe proporcionar la carga de una clase determinada.
Método de Bytecode: FORNAME ().
en la memoria y encapsula usando objetos de clase.
Otras dos formas de obtener objetos de clase:
Nombre de clase. Clase
Object.getClass ()
Crea una clase de persona simple primero
La copia del código es la siguiente:
clase pública reflejada {
Public static void main (string args []) lanza excepción
{// 1.
Class clazz = class.forname ("dsa.person");
// 2.
Class clazz1 = nueva persona (). GetClass ();
// 3.
ClassClazz2 = Person.class;
}
}
3. Método de construcción de reflexión
En la clase persona:
La copia del código es la siguiente:
/**
*Método de construcción
*/
publicPerson () {
System.out.println ("nulo");
}
publicPerson (StringName) {
System.out.println (nombre);
}
publicPerson (stringName, intpwd) {
System.out.println (nombre+"+"+pwd);
}
PrivatePerson (ListList) {
System.out.println ("List");
}
En la clase de prueba:
La copia del código es la siguiente:
// Reflection PublicPerson ()
@Prueba
publicvoidTest1 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
Constructorcr = clazz.getConstructor (null); // Obtener el objeto Constructor
Personp = (persona) CR.Newinstance (NULL); // Instanciar el objeto a través del constructor
//System.out.println(p.name);
}
// Reflection PublicPerson (StringName)
@Prueba
publicvoidTest2 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
Constructorcr = clazz.getConstructor (string.class);
Personp = (persona) CR.Newinstance ("jaja");
System.out.println (p.name);
}
// Reflection PublicPerson (StringName, intpwd)
@Prueba
publicvoidTest3 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
Constructorcr = clazz.getConstructor (string.class, int.class);
Personp = (persona) CR.Newinstance ("jaja", 1);
//System.out.println(p.name);
}
// Reflexión PublicPerson (lista de lista)
@Prueba
publicvoidTest4 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
Constructorcr = clazz.getDeClaredConstructor (list.class);
CR.SetAccessible (verdadero); // Bruta Force Cracking
Personp = (persona) CR.Newinstance (newArrayList ());
System.out.println (p.name);
}
// Otra forma de crear objetos solo es aplicable a la construcción de métodos sin parámetros
@Prueba
publicvoidTest5 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
Personp = (persona) clazz.newinstance ();
System.out.println (p.name);
}
Cuando el método de construcción es privado, ¡vamos a crack! ! !
4. Métodos convencionales de reflexión
En la clase persona:
La copia del código es la siguiente:
/**
*método
*/
publicvoidjf ()
{
}
publicvoidjf (stringName, intpwd)
{
}
PublicClass [] jf (StringName, int [] pwd)
{
returnNewClass [] {string.class, int.class};
}
privatevoidjf (inputStreamin)
{
System.out.println (in);
}
PublicStaticVoidJf (Intnum)
{
System.out.println (num);
}
PublicStaticVoidmain (StrinDargs [])
{
System.out.println ("principal !!!");
}
En la clase de prueba:
La copia del código es la siguiente:
/**
*Método reflexivo
*
*@authortanlvxu
*
*/
PublicClassDemo2 {
// Método de clase de reflexión: publicvoidjf ()
@Prueba
publicvoidTest1 () throwsexception {
Personp = Newperson ();
ClassClazz = class.forname ("rflectordemo.person");
MétodoMethod = clazz.getMethod ("jf", nulo);
método.invoke (p, nulo);
}
// Método de clase de reflexión: publicVoidJf (stringName, intpwd)
@Prueba
publicvoidTest2 () throwsexception {
Personp = Newperson ();
ClassClazz = class.forname ("rflectordemo.person");
MétodoMethod = clazz.getMethod ("jf", string.class, int.class);
método.invoke (p, "dsa", 30);
}
// Método de clase de reflexión: publicClass [] jf (stringName, int [] pwd)
@Prueba
publicvoidTest3 () throwsexception {
Personp = Newperson ();
ClassClazz = class.forname ("rflectordemo.person");
MétodoMethod = clazz.getMethod ("jf", string.class, int []. Class);
ClassCS [] = (class []) método.invoke (p, "Aads", newInt [] {1,2,3});
System.out.println (cs [0]);
}
// Método de clase de reflexión: privateVoidJF (inputStreamin)
@Prueba
publicvoidTest4 () throwsexception {
Personp = Newperson ();
ClassClazz = class.forname ("rflectordemo.person");
MétodoMethod = clazz.getDeClaredMethod ("jf", inputStream.class);
método.setAccessible (verdadero);
método.invoke (p, newFileInputStream ("d: //qqclient.txt"));
}
// Método de clase de reflexión: publicstaticVoidJf (intnum)
@Prueba
publicvoidTest5 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
MétodoMethod = clazz.getMethod ("jf", int.class);
Method.Invoke (NULL, 30);
}
// Método de clase de reflexión: PublicStaticVoidm (intnum)
@Prueba
publicvoidTest6 () throwsexception {
ClassClazz = class.forname ("rflectordemo.person");
MétodoMethod = clazz.getMethod ("main", string []. Class);
//method.invoke(null,(Object)Newstring+font>"dds "});
Method.invoke (null, newobject [] {Newstring [] {"ds", "das"}});
}
5. Campos de reflexión
En la clase persona:
La copia del código es la siguiente:
/**
*Campo
*/
PublicsTringName = "SWR";
privateintpassword = 45;
PrivateStaticItage = 35;
En la clase de prueba:
Código Java
/**
*Campos de clase reflexivo
*@authortanlvxu
*
*/
PublicClassDemo3 {
/**
*Reflection Field PublicstringName = "SWR";
*@SHONE SEXCEPTION
*/
@Prueba
publicvoidTest1 () throwsexception
{
Personp = Newperson ();
ClassClazz = class.forname ("rflectordemo.person");
Fieldf = clazz.getfield ("nombre");
// Obtener el valor del campo
ObjectValue = f.get (p);
// Obtener el tipo de campo
Classtype = f.gettype ();
if (type.equals (string.class)) {
StringName = (String) F.Get (P);
System.out.println (nombre);
}
// Establecer el valor del campo
f.set (p, "dfafa");
System.out.println (p.name);
}
/**
*Campo de reflexión PrivateIntPassword;
*@SHONE SEXCEPTION
*/
@Prueba
publicvoidTest2 () throwsexception
{
Personp = Newperson ();
ClassClazz = class.forname ("rflectordemo.person");
Fieldf = clazz.getDeclaredField ("contraseña");
F.SetAccessible (verdadero);
f.set (p, 36);
System.out.println (f.get (p));
}
/**
*Campo de reflexión PrivateStaticItilge = 35;
*@SHONE SEXCEPTION
*/
@Prueba
publicvoidTest3 () throwsexception
{
ClassClazz = class.forname ("rflectordemo.person");
Fieldf = Clazz.getDeclaredField ("Age");
F.SetAccessible (verdadero);
f.set (nulo, 24);
System.out.println (f.get (nulo));
}
De hecho, no importa el método de construcción de reflexión o los campos, ¡podemos aprender de él uno por uno!