La reflexión es la programación de Java un lenguaje de las características, que permite ejecutar programas Java en su propia inspección, o "examen de conciencia", y se puede atribuir directamente a los procedimientos de funcionamiento interno.Por ejemplo, se puede obtener un nombre de clase Java de cada miembro y la pantalla.
Java, en la aplicación práctica de esta capacidad puede ser utilizado no son muchos, pero en otros lenguajes de programación esta característica, simplemente no existe.Por ejemplo, Pascal, C o C + +, no hay manera de conseguir la definición de la función de la información relacionados con el programa.
JavaBean es un reflejo de la aplicación práctica, permite que las herramientas de visualización de funcionamiento los componentes de software.Estas herramientas se cargan de forma dinámica a través de la reflexión y obtener los componentes de Java (clases) de la propiedad.
1. Un ejemplo sencillo
Consideremos el siguiente ejemplo, vamos a ver cómo la reflexión de trabajo.
importación java.lang.reflect .*;
pública DumpMethods clase {
public static void main (String args []) {
try {
Clase c = Class.forName (args [0]);
Método m [] = c.getDeclaredMethods ();
for (int i = 0; i m.length ; i + +)
System.out.println (m [i] ToString ().);
} Catch (Throwable e) {
System.err.println (e);
}
}
}
Sentencia se ejecuta de la siguiente manera:
java DumpMethods java.util.Stack
Es la salida resultante es:
java.util.Stack.push java.lang.Object público (java.lang.Object)
pública java.lang.Object sincronizado java.util.Stack.pop ()
pública java.lang.Object sincronizado java.util.Stack.peek ()
java.util.Stack.empty public boolean ()
public int sincronizado java.util.Stack.search (java.lang.Object)
Esto muestra el nombre de cada clase java.util.Stack método y su clasificación y tipo de retorno.
Este programa utiliza Class.forName para cargar la clase especificada, a continuación, llamar para obtener esta clase getDeclaredMethods define una lista de métodos.java.lang.reflect.Methods se utiliza para describir un único método de una clase de una clase.
2. Introducción de reflexión
Para la reflexión de la clase, tales como el método, se pueden encontrar en el paquete java.lang.relfect.Al utilizar estas clases deben seguir tres pasos: El primer paso es conseguir que la clase que usted desea operar objeto java.lang.Class.Correr en el programa Java, con la clase java.lang.Class para describir las clases e interfaces.
Aquí es obtener un objeto de clase los métodos:
Clase c = Class.forName ("java.lang.String");
Esta declaración para obtener una clase String objeto de la clase.Hay otra manera, como la siguiente declaración:
Clase c = int.class;
O
Clase c = Integer.TYPE;
Reciben tipos básicos de información de clase.Visite uno de los último método es el tipo básico del paquete (como Integer) en el campo TIPO predefinidos.
El segundo paso es llamar al método, como getDeclaredMethods para obtener todos los métodos definidos en la lista de clase.
Una vez que han obtenido esta información, el tercer paso puede llevarse a cabo - y utilizar la API de reflexión para manipular la información, como por ejemplo el siguiente código:
Clase c = Class.forName ("java.lang.String");
Método m [] = c.getDeclaredMethods ();
System.out.println (m [0] ToString ().);
Se imprimirá como texto método String define en el primer prototipo.
En el ejemplo siguiente, los tres pasos para hacer frente a aplicaciones específicas para utilizar la reflexión para dar ejemplos.
Analog operador instanceof
Después de obtener la información de clase, por lo general el paso siguiente es resolver sobre el objeto de clase de algunas cuestiones básicas.Por ejemplo, el método Class.isInstance puede ser utilizado para simular el operador instanceof:
class A {
}
public class instance1 {
public static void main (String args []) {
try {
Clase CLS = Class.forName ("A");
booleano b1 = cls.isInstance (new Integer (37));
System.out.println (b1);
booleano b2 = cls.isInstance (Un nuevo ());
System.out.println (B2);
} Catch (Throwable e) {
System.err.println (e);
}
}
}
En este ejemplo se crea una clase de objetos de clase A, y luego comprobar si un objeto es una instancia de A.Entero (37) no es, pero es la nueva A ().
3. Para encontrar métodos de la clase
Encuentra una clase define qué métodos, se trata de un uso muy valiosos de reflexión muy básica.El siguiente código realiza este uso:
importación java.lang.reflect .*;
public class metodo1 {
private int f1 (p objetos, int x) throws NullPointerException {
if (p == null)
arroja NullPointerException nuevo ();
return x;
}
public static void main (String args []) {
try {
Clase CLS = Class.forName ("metodo1");
methlist Método [] = cls.getDeclaredMethods ();
for (int i = 0; i methlist.length ; i + +) {
Método m = methlist [i];
System.out.println ("nombre =" + m.getName ());
System.out.println ("clase decl =" + m.getDeclaringClass ());
Clase PVEC [] = m.getParameterTypes ();
for (int j = 0; pvec.length j, j + +)
System.out.println ("param #" + j + "" + PVEC [j]);
Clase evec [] = m.getExceptionTypes ();
for (int j = 0; evec.length j, j + +)
System.out.println ("Sin IVA #" + j + "" + evec [j]);
System.out.println ("tipo de retorno =" + m.getReturnType ());
System.out.println ("-----");
}
} Catch (Throwable e) {
System.err.println (e);
}
}
}
Este primer programa de obtener una descripción de metodo1 clase, a continuación, llamar getDeclaredMethods para obtener una serie de objetos Método, que se definen en la clase de describir cada uno de los métodos, incluyendo métodos públicos, los métodos de protección, métodos de paquetes y métodos privados.Si utiliza el programa para reemplazar getDeclaredMethods getMethods, usted puede conseguir todos los métodos heredados.
Método para obtener una lista de objetos, los parámetros de estos métodos para mostrar el tipo de los tipos de excepción y los tipos de valor de retorno no es difícil.Estos tipos son el tipo de base o tipo de clase, puede describir la clase de objetos por el orden indicado.
El resultado es el siguiente:
name = f1
clase decl = class metodo1
param # 0 clase java.lang.Object
param # 1 int
exc # 0 clase java.lang.NullPointerException
el tipo de devolución = int
-----
name = principal
clase decl = class metodo1
param # 0 clase [Ljava.lang.String;
tipo de valor devuelto = vacío
4. Obtener información constructor
Clase constructor para el uso de las anteriores por el uso de métodos similares, tales como:
importación java.lang.reflect .*;
public class constructor1 {
pública constructor1 () {
}
protegidas constructor1 (int i, doble d) {
}
public static void main (String args []) {
try {
Clase CLS = Class.forName ("constructor1");
Constructor ctorlist [] = cls.getDeclaredConstructors ();
for (int i = 0; i ctorlist.length ; i + +) {
Constructor ct = ctorlist [i];
System.out.println ("nombre =" + ct.getName ());
System.out.println ("clase decl =" + ct.getDeclaringClass ());
Clase PVEC [] = ct.getParameterTypes ();
for (int j = 0; pvec.length j, j + +)
System.out.println ("param #" + j + "" + PVEC [j]);
Clase evec [] = ct.getExceptionTypes ();
for (int j = 0; evec.length j, j + +)
System.out.println ("Sin IVA #" + j + "" + evec [j]);
System.out.println ("-----");
}
} Catch (Throwable e) {
System.err.println (e);
}
}
}
Este caso no recuperar el tipo de información, es porque el constructor no devuelve el tipo.
El resultado de la ejecución:
name = constructor1
clase decl = class constructor1
-----
name = constructor1
clase decl = class constructor1
param # 0 int
param # 1 doble
5. Para el campo de la clase (de dominio)
Encuentra una clase define qué campos de datos son también posibles, el siguiente código en seco esta cosa:
importación java.lang.reflect .*;
public class {campo1
privadas dobles d;
pública i estática final int = 37;
String s = "prueba";
public static void main (String args []) {
try {
Clase CLS = Class.forName ("campo1");
Campo fieldlist [] = cls.getDeclaredFields ();
for (int i = 0; i fieldlist.length ; i + +) {
Campo fld = fieldlist [i];
System.out.println ("nombre =" + fld.getName ());
System.out.println ("clase decl =" + fld.getDeclaringClass ());
System.out.println ("type =" + fld.getType ());
int mod = fld.getModifiers ();
System.out.println ("modificadores =" + Modifier.toString (mod));
System.out.println ("-----");
}
} Catch (Throwable e) {
System.err.println (e);
}
}
}
En este ejemplo, y es muy similar al ejemplo anterior.Ejemplo, utiliza algo nuevo modificador, también es una clase de reflexión, los miembros del modificador se utiliza para describir el campo, tales como "private int".Estos modificadores descritos por el propio entero, y el uso Modifier.toString para volver a la "oficial" descripción de la orden de la cadena (como "estática" en el "final" antes).La producción de este programa es:
name = d
clase decl = class campo1
type = doble
modificadores = privada
-----
name = i
clase decl = class campo1
type = int
modificadores = public static final
-----
name = s
clase decl = class campo1
type = java.lang.String clase
modificadores =
La situación y buscar formas de obtener el campo sólo puede lograrse cuando la clase en el estado actual de la información de campo (getDeclaredFields), o usted puede conseguir la clase padre define los campos (getFields).
6. De acuerdo con el nombre de método del método
Texto aquí, sin excepción, todos los ejemplos y cómo obtener información acerca de la clase.También puede utilizar la reflexión para hacer otras cosas, como el método de aplicación de la especificación de un nombre.En el ejemplo siguiente se muestra el texto siguiente:
importación java.lang.reflect .*;
public class method2 {
public int suma (int a int, b) {
volver a + b;
}
public static void main (String args []) {
try {
Clase CLS = Class.forName ("method2");
Clase partypes [] = new Class [2];
partypes [0] = Integer.TYPE;
partypes [1] = Integer.TYPE;
Método = cls.getMethod metanfetamina ("agregar", partypes);
method2 methobj = new method2 ();
Objeto arglist [] = new Object [2];
arglist [0] = new Integer (37);
arglist [1] = new Integer (47);
Objeto retobj = meth.invoke (arglist methobj);
retval = entero (número entero) retobj;
System.out.println (retval.intValue ());
} Catch (Throwable e) {
System.err.println (e);
}
}
}
Si en algún lugar de la ejecución de un programa cuando se es consciente de la necesidad de realizar un método, este método es el nombre del programa se está ejecutando en el específico (por ejemplo, el medio ambiente JavaBean desarrollo haría tal cosa), entonces el procedimiento anteriormuestra la forma de hacerlo.
En el ejemplo anterior, GetMethod utilizado para encontrar dos parámetros enteros y un método llamado add.Encontrar el método y crear el objeto correspondiente método, la instancia del objeto en el derecho a realizarlo.La aplicación del método, la necesidad de proporcionar una lista de parámetros, que en el ejemplo anterior es un número entero, respectivamente, 37 y 47 vueltas de dos objetos enteros.método de ejecución es un entero devolver el mismo objeto, que encapsula el valor de retorno de 84 años.
7. Para crear un nuevo objeto
Para el constructor, que no le gusta la aplicación de métodos, porque significa la aplicación de un constructor crea un nuevo objeto (para ser exactos, el proceso de creación de un objeto en particular la asignación de la memoria y la construcción de un objeto).Así, con el ejemplo más similar al ejemplo anterior de la siguiente manera:
importación java.lang.reflect .*;
public class constructor2 {
pública constructor2 () {
}
pública constructor2 (int a int, b) {
System.out.println ("a =" + a + "b =" + b);
}
public static void main (String args []) {
try {
Clase CLS = Class.forName ("constructor2");
Clase partypes [] = new Class [2];
partypes [0] = Integer.TYPE;
partypes [1] = Integer.TYPE;
ct = Constructor cls.getConstructor (partypes);
Objeto arglist [] = new Object [2];
arglist [0] = new Integer (37);
arglist [1] = new Integer (47);
Objeto retobj ct.newInstance = (arglist);
} Catch (Throwable e) {
System.err.println (e);
}
}
}
De acuerdo con el tipo de parámetro especificado para encontrar el constructor adecuado y ejecutarlo para crear una nueva instancia de objeto.Este método se puede utilizar en tiempo de ejecución para crear dinámicamente el objeto, en lugar de crear objetos en tiempo de compilación, que es muy valiosa.
8. Cambie el campo (campo) de un valor
También hay una reflexión útil del objeto es cambiar el campo de valor de datos.la reflexión de un programa en ejecución para encontrar los objetos por su nombre en el campo y el cambio, el siguiente ejemplo para ilustrar este punto:
importación java.lang.reflect .*;
public class campo2 {
public double d;
public static void main (String args []) {
try {
Clase CLS = Class.forName ("campo2");
Campo fld cls.getField = ("d");
campo2 f2obj campo2 = new ();
System.out.println ("d =" + f2obj.d);
fld.setDouble (f2obj, 12.34);
System.out.println ("d =" + f2obj.d);
} Catch (Throwable e) {
System.err.println (e);
}
}
}
En este ejemplo, el valor del campo es cambiado por d 12.34.
9. Utilización de matrices
En este artículo se describe el reflejo de la operación final es crear una matriz de uso.Matriz en el lenguaje Java es un tipo de clase especial, una referencia de la matriz se puede asignar la referencia de objetos.Mira el siguiente ejemplo para ver cómo el trabajo de la matriz:
importación java.lang.reflect .*;
public class matriz1 {
public static void main (String args []) {
try {
Clase CLS = Class.forName ("java.lang.String");
Objeto arr = Array.newInstance (cls, 10);
Array.set (arr, 5, "esta es una prueba");
String s = (String) Array.get (arr, 5);
System.out.println (s);
} Catch (Throwable e) {
System.err.println (e);
}
}
}
Los casos de 10 unidades para crear una matriz de cadenas de longitud, de los 5 primeros puestos de la cadena le asigna un valor y, finalmente, obtener la cadena de la matriz e imprimirlo.
El código siguiente proporciona un ejemplo más complejo:
importación java.lang.reflect .*;
public class matriz2 {
public static void main (String args []) {
atenúa int [] = new int [] {5, 10, 15};
Objeto arr = Array.newInstance (Integer.TYPE, atenúa);
Objeto arrobj = Array.get (arr, 3);
Clase CLS = arrobj.getClass () GetComponentType ().;
System.out.println (CLS);
arrobj = Array.get (arrobj, 5);
Array.setInt (arrobj, 10, 37);
[][][] Arrcast int = (int arr [][][]);
System.out.println (arrcast [3] [5] [10]);
}
}
Ejemplo se crea un 5 x 10 x 15 matriz de enteros, y en [3] [5] [10] le asigna un valor de 37 elementos.Tenga en cuenta que las matrices multidimensionales son en realidad las matrices de matrices, por ejemplo, después de la primera Array.get, arrobj es una matriz de 10 x 15.A continuación, obtener uno de los elementos, es decir, una matriz de longitud 15, y el uso Array.setInt de sus primeros 10 elementos de la cesión.
Tenga en cuenta que al crear el tipo de matriz es dinámica, en tiempo de compilación no conoce su tipo.