Análisis en profundidad de la reflexión de Java (recomendado)

Este artículo todavía usa pequeños ejemplos para ilustrar, porque siempre siento que el caso es el mejor, de lo contrario, si solo lee la teoría, no la entenderá después de leerla. Sin embargo, se recomienda que recuerde la teoría después de leer el artículo y tenga una mejor comprensión.

El texto principal comienza a continuación.

[Caso 1] Obtenga el paquete completo y el nombre de la clase a través de un objeto

 paquete refleja; /*** Obtenga el nombre completo del paquete y el nombre de clase a través de un objeto**/class demo {// otros códigos ...} class Hello {public static void main (string [] args) {demo demo = new Demo (); System.out.println (demo.getClass (). GetName ()); }}

【Resultado en ejecución】: reflej.demo

Agregue una oración: todos los objetos de las clases son en realidad instancias de clase.

【Caso 2】 Objeto de clase instanciación

 paquete refleja; Class Demo {// Otros códigos ...} clase Hello {public static void main (string [] args) {class <?> demo1 = null; Clase <?> Demo2 = null; Clase <?> Demo3 = null; intente {// generalmente intente usar este formulario demo1 = class.forname ("reflej.demo"); } catch (Exception e) {E.PrintStackTrace (); } demo2 = new Demo (). GetClass (); demo3 = demo.class; System.out.println ("Nombre de clase"+demo1.getName ()); System.out.println ("Nombre de clase"+demo2.getName ()); System.out.println ("Nombre de clase"+demo3.getName ()); }}

【Resultados de la operación】:
Clase namereflect.demo
Clase namereflect.demo
Clase namereflect.demo

[Caso 3] Instanciar objetos de otras clases a través de la clase

Objetos instanciados mediante la construcción de no parámetros

 Persona pública (nombre de cadena, int Age) {this.age = Age; this.name = name; }

Luego continúe ejecutando el programa anterior y aparecerá:

Entonces, cuando escribe objetos que usan la clase para instanciar otras clases, debe definir su propio constructor sin parámetros.

[Caso] Llame a constructores en otras clases a través de la clase (también puede crear objetos de otras clases a través de la clase de esta manera)

 paquete refleja; import java.lang.reflect.constructor; Persona de clase {Public Person () {} Public Person (nombre de cadena) {this.name = name; } persona pública (int Age) {this.age = Age; } persona pública (nombre de cadena, int Age) {this.age = Age; this.name = name; } public String getName () {nombre de retorno; } public int getAge () {return Age; } @Override public string toString () {return "["+this.name+""+this.age+"]"; } nombre de cadena privada; edad privada int; } class Hello {public static void main (string [] args) {class <?> demo = null; prueba {demo = class.forname ("reflejar.person"); } catch (Exception e) {E.PrintStackTrace (); } Persona per1 = nulo; Persona per2 = nulo; Persona per3 = nulo; Persona per4 = nulo; // Obtener todos los constructores Constructor <?> Cons [] = demo.getConstructors (); intente {per1 = (persona) Cons [0] .newinstance (); per2 = (persona) contras [1] .Newinstance ("Rollen"); per3 = (persona) contras [2] .Newinstance (20); per4 = (persona) contras [3] .Newinstance ("Rollen", 20); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (PER1); System.out.println (PER2); System.out.println (PER3); System.out.println (PER4); }}

【Resultados de la operación】:

[NULL 0]
[Rollen 0]
[NULL 20]
[Rollen 20]

【Caso】

Devuelve la interfaz implementada por una clase:

 paquete refleja; interfaz China {public static static final string name = "rollen"; Public estática int Age = 20; Vacío público Sayschina (); public void Sayshello (nombre de cadena, int Age); } La persona de clase implementa China {Public Person () {} Public Person (String Sex) {this.sex = sex; } public String getsex () {return sex; } public void setsex (sexo de cadena) {this.sex = sex; } @Override public void saychina () {System.out.println ("Hola, China"); } @Override public void sayshello (nombre de cadena, int a age) {System.out.println (nombre+""+edad); } sexo de cadena privada; } class Hello {public static void main (string [] args) {class <?> demo = null; prueba {demo = class.forname ("reflej.person"); } catch (Exception e) {E.PrintStackTrace (); } // Guardar todas las interfaces clase <?> Intes [] = demo.getInterfaces (); for (int i = 0; i <intes.length; i ++) {system.out.println ("interfaz implementada"+intes [i] .getName ()); }}}

【Resultados de la operación】:

Interfaz implementada refleja.China

(Tenga en cuenta que los siguientes ejemplos utilizarán la clase persona de este ejemplo, por lo que para ahorrar espacio, ya no pegaremos la parte del código de la persona aquí, solo el código de la clase principal hola)

【Caso】: Obtenga la clase principal en otras clases

 clase hola {public static void main (string [] args) {class <?> Demo = null; prueba {demo = class.forname ("reflej.person"); } catch (Exception e) {E.PrintStackTrace (); } // Obtener la clase principal de clase <?> Temp = demo.getSuperClass (); System.out.println ("La clase principal heredada es:"+temp.getName ()); }}

【Ejecución de resultados】

La clase principal heredada es: java.lang.object

【Caso】: Obtenga todos los constructores en otras clases

Este ejemplo requiere agregar importar java.lang.reflect.* Al comienzo del programa;
Luego escriba la clase principal como:

 clase hola {public static void main (string [] args) {class <?> Demo = null; prueba {demo = class.forname ("reflejar.person"); } catch (Exception e) {E.PrintStackTrace (); } Constructor <?> Cons [] = demo.getConstructors (); for (int i = 0; i <cons.length; i ++) {system.out.println ("constructor:"+cons [i]); }}}

【Resultados de la operación】:

Método de construcción: Public Reflect.person ()
Constructor: Public Reflect.person (java.lang.string)

Pero los lectores cuidadosos encontrarán que el constructor anterior no tiene modificadores como público o privado

Obtengamos el modificador en el siguiente ejemplo

 clase hola {public static void main (string [] args) {class <?> Demo = null; prueba {demo = class.forname ("reflej.person"); } catch (Exception e) {E.PrintStackTrace (); } Constructor <?> Cons [] = demo.getConstructors (); for (int i = 0; i <cons.length; i ++) {class <?> P [] = Cons [i] .getParametertyPes (); System.out.print ("Constructor:"); int mo = cons [i] .getModifiers (); System.out.print (modificador.toString (mo)+""); System.out.print (contras [i] .getName ()); System.out.print ("("); for (int j = 0; j <p.length; ++ j) {system.out.print (p [j] .getName ()+"arg"+i); if (j <p.length-1) {system.out.print (",");}} system.println (") {}"); }}}

【Resultados de la operación】:

Constructor: public reflex.person () {}
Constructor: public reflex.person (java.lang.string arg1) {}

A veces puede haber excepciones en un método, jaja. Echemos un vistazo:

 clase hola {public static void main (string [] args) {class <?> Demo = null; prueba {demo = class.forname ("reflej.person"); } catch (Exception e) {E.PrintStackTrace (); } Método método [] = demo.getMethods (); for (int i = 0; i <métod.length; ++ i) {class <?> returntype = método [i] .getReturnType (); Clase <?> Para [] = método [i] .getParametertypes (); int temp = método [i] .getModifiers (); System.out.print (modificador.toString (temp)+""); System.out.print (returntype.getName ()+""); System.out.print (método [i] .getName ()+""); System.out.print ("("); for (int j = 0; j <para.length; ++ j) {system.out.print (para [j] .getName ()+""+"arg"+j); if (j <para.length-1) {system.out.print (",");}} class <?> Excebe [] = Methode.]. if (excce.length> 0) {system.out.print (") lanza"); for (int k = 0; k <excce.length; ++ k) {system.out.print (excce [k] .getName ()+""); if (k <excce.length-1) {system.out.print (","); }}}} else {System.out.print (")"); } System.out.println (); }}}

[Caso] A continuación, obtengamos todas las propiedades de otras clases. Finalmente, los ordenaré juntos, es decir, para obtener todo el marco de una clase a través de la clase

 clase hola {public static void main (string [] args) {class <?> Demo = null; prueba {demo = class.forname ("reflej.person"); } catch (Exception e) {E.PrintStackTrace (); } System.out.println("=========================================================================================== =======================================================================================================================================================================================================================================================================================. =======================================================================================================================================================================================================================================================================================. ================================================================================================================ Modificador de permiso int mo = field [i] .getModifiers (); System.out.println("====================================================================================== =========================================================================================================== ========================================================================================================== =========================================================================================================== archivado1 = demo.getfields (); for (int j = 0; j <fileD1.length; j ++) {// modificador de permiso int mo = filed1 [j] .getModifiers (); String priv = modificador.ToString (Mo); // Class de tipo de propiedad <?> Type = filed1 [j] .gettype (); System.out.println (priv + "" + type.getName () + "" + archivado1 [j] .getName () + ";"); }}}

【Resultados de la operación】:

====================================================
Java.lang. Sexo privado;
=============================================================
Nombre de Java.lang.String de Public Static;
Pública estática Final Int Age;

[Caso] De hecho, los métodos en otras clases también se pueden llamar a través de la reflexión:

 clase hola {public static void main (string [] args) {class <?> Demo = null; prueba {demo = class.forname ("reflejar.person"); } catch (Exception e) {E.PrintStackTrace (); } try {// llamando al método saychina en el método de clase de persona = demo.getMethod ("saychina"); método.invoke (demo.newinstance ()); // llamando al método sayhello de la persona = demo.getMethod ("sayhello", string.class, int.class); método.invoke (demo.newinstance (), "rollen", 20); } catch (Exception e) {E.PrintStackTrace (); }}}

【Resultados de la operación】:

Hola China
Rollen 20

【Caso】 Conjunto de llamadas y obtenga métodos de otras clases

 clase hola {public static void main (string [] args) {class <?> Demo = null; Objero obj = nulo; prueba {demo = class.forname ("reflejar.person"); } catch (Exception e) {E.PrintStackTrace (); } try {obj = demo.newinstance (); } catch (Exception e) {E.PrintStackTrace (); } setter (obj, "sexo", "masculino", string.class); Getter (obj, "sexo"); } / ** * @param obj * objeto de operación * @param att * atributos de la operación * * / public static void getter (object obj, string att) {try {método método = obj.getClass (). getMethod ("get" + att); System.out.println (métod.invoke (obj)); } catch (Exception e) {E.PrintStackTrace (); }} / ** * @param obj * objeto de la operación * @param att * atributos de la operación * @param value * set valor * @param type * atributos del parámetro * * / public static void setter (obj obj, string att, valor de objeto, class <?> type) {try {método = obj.getClass (getMethod ("set" + att, type type) {try {método = obj.getClass (). getMethod ("set" + att, type type) {try {método = obj.getClass (getMethod ("set" + att, type); método.invoke (obj, valor); } catch (Exception e) {E.PrintStackTrace (); }}} // Clase final

【Resultados de la operación】:

masculino

【Caso】 Operación por reflexión

 Hello Hello {public static void main (string [] args) lanza la excepción {class <?> demo = null; Objero obj = nulo; demo = class.forname ("reflej.person"); obj = demo.newinstance (); Campo campo = demo.getDeclaredfield ("sexo"); campo.setAccessible (verdadero); campo.set (obj, "masculino"); System.out.println (field.get (obj)); }} // clase final

[Caso] Obtenga y modifique la información de la matriz a través de la reflexión:

 import java.lang.reflect.*; clase hola {public static void main (string [] args) {int [] temp = {1,2,3,4,5}; Clase <?> Demo = temp.getClass (). GetComponentType (); System.out.println ("Tipo de matriz:"+demo.getName ()); System.out.println ("Longitud de matriz"+Array.getLength (temp)); System.out.println ("Primer elemento de la matriz:"+array.get (temp, 0)); Array.set (temp, 0, 100); System.out.println ("Después de modificar el primer elemento de la matriz es:"+array.get (temp, 0)); }}

【Resultados de la operación】:

Tipo de matriz: int
Longitud de la matriz 5
El primer elemento de la matriz: 1
Después de la modificación, el primer elemento de la matriz es: 100

【Caso】 Modifique el tamaño de la matriz a través de la reflexión

 clase Hello {public static void main (string [] args) {int [] temp = {1,2,3,4,5,6,7,8,9}; int [] newtemp = (int []) Arrayinc (temp, 15); imprimir (newtemp); System.out.println("================================================================================= =============================================================================================================================================================================================================. String []) Arrayinc (ATR, 8); System.ArrayCopy (OBJ, 0, Newarr, 0, CO); Array.getLength (obj);

【Resultados de la operación】:

La longitud de la matriz es: 15
1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 ===========================================
La longitud de la matriz es: 8
ABC NULL NULL NULL NULL NULL

Agente dinámico

[Caso] Primero, echemos un vistazo a cómo obtener el cargador de clase:

 Test de clase {} clase Hello {public static void main (string [] args) {test t = new test (); System.out.println ("ClassLoader"+T.GetClass (). GetClassLoader (). GetClass (). GetName ()); }}

【Salida del programa】:

Class Loader Sun.misc.launcher $ AppClassLoader

De hecho, hay tres tipos de cargadores de clase en Java.

1) Bootstrap ClassLoader Este cargador está escrito en C ++ y rara vez se ve en el desarrollo general.

2) El cargador de clases de extensión se utiliza para cargar clases extendidas, generalmente correspondientes a clases en el directorio JRE/lib/ext

3) AppClassLoader carga la clase especificada por classpath y es el cargador más utilizado. También es el cargador predeterminado en Java.

Si desea completar un proxy dinámico, primero debe definir una subclase de la interfaz InvocationHandler, y se ha completado la operación específica del proxy.

 paquete refleja; import java.lang.reflect.*; // Definir sujeto de interfaz de interfaz de proyecto {public String Says (Nombre de cadena, int Age); } // Definir la clase de proyecto real RealSubject implementa sujeto {@Override public String Says (String Name, Int Age) {Nombre de retorno + "" + Age; }} class myInVocationHandler implementa InvocationHandler {objeto privado obj = null; Public Object Bind (Obj Obj) {this.obj = obj; return proxy.newproxyInstance (obj.getClass (). getClassLoader (), obj .getClass (). getInterfaces (), esto); } @Override public Object Invoke (Object Proxy, Method Method, Object [] args) lanza lando {objeto temp = método.invoke (this.obj, args); regresar temp; }} clase Hello {public static void main (string [] args) {myInVocationHandler demo = new MyInVocationHandler (); Sujeto sub = (sujeto) demo.bind (new RealSubject ()); String info = sub.say ("rollen", 20); System.out.println (info); }}

【Resultados de la operación】:
Rollen 20

El ciclo de vida de una clase

Después de compilar una clase, el siguiente paso es comenzar a usar la clase. Si quieres usar una clase, definitivamente es inseparable de JVM. Durante la ejecución del programa, el JVM se completa a través de estos tres pasos: carga, vinculación e inicialización.

La carga de clase se realiza a través de un cargador de clase. El cargador carga el archivo binario del archivo .class en el área del método JVM y crea un objeto java.lang.class que describe esta clase en el área de montón. Utilizado para encapsular datos. Pero la misma clase solo será cargada por el cargador de clases antes

Los enlaces son para ensamblar datos binarios en un estado que se puede ejecutar.

El enlace se divide en tres etapas: verificación, preparación y análisis

La verificación generalmente se usa para confirmar si este archivo binario es adecuado para el JVM (versión) actual.

La preparación es asignar espacio de memoria para miembros estáticos. y establecer valores predeterminados

El análisis se refiere al proceso de convertir el código en el grupo constante como referencia directa hasta que el programa de ejecución pueda utilizar todas las referencias simbólicas (establecer una correspondencia completa)

Después de la finalización, el tipo se inicializa. Después de la inicialización, el objeto de la clase se puede usar normalmente. Después de que ya no se usa un objeto, se recolectará basura. Libre espacio.

Cuando no apunta a la clase del objeto de clase, se desinstalará, terminando el ciclo de vida de la clase

Use reflexión para el modo de fábrica

Echemos un vistazo al modo de fábrica si no necesita reflexión:

 / *** @Author Rollen-Holt Modo de patrón de diseño*/ Interface Fruit {public abstract void eat (); } clase Apple implementa fruta {public void eat () {System.out.println ("Apple"); }} clase Orange implementa fruta {public void eat () {System.out.println ("naranja"); }} // Construye la clase de fábrica // En otras palabras, si solo necesitamos modificar la clase de fábrica al agregar otras instancias en la clase futura de fábrica {public static fruts getInstance (string frutsname) {fruts f = null; if ("manzana" .equals (fruitName)) {f = new Apple (); } if ("naranja" .equals (fruitName)) {f = new Orange (); } return f; }} clase Hello {public static void main (string [] a) {fruit f = factory.getInstance ("naranja"); logro(); }}

De esta manera, cuando agregamos una subclase, necesitamos modificar la clase de fábrica. Si agregamos demasiadas subclases, cambiaremos mucho.

Ahora echemos un vistazo al mecanismo de reflexión de uso:

 paquete refleja; Interface Fruit {public abstract void eat (); } clase Apple implementa fruta {public void eat () {System.out.println ("Apple"); }} clase Orange implementa fruta {public void eat () {System.out.println ("naranja"); }} class Factory {public static fruts getInstance (String className) {fruts f = null; intente {f = (fruit) class.forname (classname) .newinstance (); } catch (Exception e) {E.PrintStackTrace (); } return f; }} class Hello {public static void main (string [] a) {fruit f = factory.getInstance ("reflej.apple"); if (f! = null) {f.eat (); }}}

Ahora, incluso si agregamos tantas subclases, la clase de fábrica no necesita ser modificada.

Aunque el amor anterior puede obtener una instancia de la interfaz a través de la reflexión, debe pasar el paquete completo y el nombre de la clase. Además, los usuarios no pueden saber cuántas subclases se pueden usar en una interfaz, por lo que configuramos las subclases requeridas en forma de archivos de atributos.

Echemos un vistazo: Modo de fábrica Combinando archivos de atributo

Primero cree un archivo de recursos fruit.properties.

Los contenidos son:

 Apple = reflej.apple naranja = reflej.orange

Luego escriba el código de clase principal:

 paquete refleja; import java.io.*; import java.util.*; Interface Fruit {public abstract void eat (); } clase Apple implementa fruta {public void eat () {System.out.println ("Apple"); }} clase Orange implementa fruta {public void eat () {System.out.println ("naranja"); }} // operar la clase de archivo de propiedades init {Public static Properties getPro () lanza FileNotFoundException, ioException {Properties pro = new Properties (); Archivo f = nuevo archivo ("fruit.properties"); if (f.exists ()) {pro.load (new FileInputStream (f)); } else {pro.setProperty ("Apple", "reflej.apple"); pro.setProperty ("naranja", "reflej.orange"); pro.store (nuevo FileOutputStream (f), "clase de frutas"); } return pro; }} class Factory {public static fruts getInstance (String className) {fruts f = null; intente {f = (fruit) class.forname (classname) .newinstance (); } catch (Exception e) {E.PrintStackTrace (); } return f; }} clase Hello {public static void main (string [] a) lanza FileNotFoundException, ioException {Properties pro = init.getPro (); fruta f = fábrica.getInstance (pro.getProperty ("manzana")); if (f! = null) {f.eat (); }}}

El análisis en profundidad anterior de la reflexión de Java (recomendado) es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.