Explicación detallada de la reflexión de Java
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 reflejado; clase de clase {// Otros códigos ...} class 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
paquete refleja; Persona de clase {public String getName () {Return Name; } public void setName (nombre de cadena) {this.name = name; } public int getAge () {return Age; } public void setAge (int Age) {this.age = edad; } @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 ("reflej.person"); } catch (Exception e) {E.PrintStackTrace (); } Persona per = nulo; intente {per = (persona) demo.newinstance (); } Catch (InstanciationException e) {// TODO Auto Generado Bloque E.PrintStackTrace (); } Catch (ilegalAccessException e) {// TODO Auto Generado Bloque E.PrintStackTrace (); } per.setName ("rollen"); per.setage (20); System.out.println (per); }}【Resultados de la operación】:
[Rollen 20]
Pero tenga en cuenta que cuando cancelamos el constructor predeterminado sin parámetros en persona, por ejemplo, después de definir solo un constructor con parámetros, se producirá un error:
Por ejemplo, definí un constructor:
Persona pública (nombre de cadena, int Age) {this.age = Age; this.name = name; }Luego continúe ejecutando el programa anterior y aparecerá:
java.lang.instantiationException: reflejar.person
en java.lang.class.newinstance0 (class.java:340)
en java.lang.class.newinstance (class.java:308)
en reflej.hello.main (hola.java:39)
Excepción en el hilo "principal" java.lang.nullpointerexception
en reflej.hello.main (hola.java:47)
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; private int Age;} class Hello {public static void main (string [] args) {class <?> demo = null; prueba {demo = class.forname ("reflej.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);} 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); } private String Sex;} clase 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 ("reflej.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 ("reflejar.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 ("reflejar.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 (); }}}【Resultados de la operación】:
Public java.lang.string getsex ()
Public void setsex (java.lang.string arg0)
Vacío público Sayschina ()
Public Void Sayshello (java.lang.string arg0, int arg1)
Public Final Native Void Wait (Long Arg0) lanza java.lang.interruptedException
Public Final void Wait () lanza java.lang.interruptedException
Public Final Now Wait (Long Arg0, int Arg1) lanza java.lang.interruptedException
Público booleano iguales (java.lang.object arg0)
Public java.lang.string toString ()
público nativo int hashcode ()
Público final Java.lang.class getClass ()
Público Final Native Void notify ()
Público Final Native Void notifyall ()
[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 ("reflej.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 ("reflej.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 Hello {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 reflejar; import java.lang.reflect.*; // Definir sujeto de interfaz de interfaz de proyecto {public String Says (String Name, int Age);} // Definir la clase de proyecto Real RealSubject implementa sujeto {@Override public String Says (String Name, Int Age) {Return Name + "" + 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:
http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html
/ *** @Author Rollen-Holt Factory Mode of Design Pattern*/ Interface Fruit {public abstract void eat ();} class 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 ();} class 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 = reflejar. Apple
naranja = reflejar. Orange
Luego escriba el código de clase principal:
paquete refleja; import java.io.*; import java.util.*; Interface Fruit {public abstract void eat ();} class Apple implementa fruta {public void eat () {System.out.println ("Apple"); }} clase Orange implementa fruta {public void eat () {System.out.println ("naranja"); }} // Operation Property File Clase 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 (); }}}【Resultado de ejecución】: Apple
Lo anterior es una explicación detallada del mecanismo de reflexión de Java. Continuaremos agregando información relevante en el futuro. ¡Gracias por su apoyo para este sitio!