la reflexión de Java de la tecnología subyacente

 Hoy te explico la tecnología básica de la reflexión de Java, si mal o mala puede ser un montón de hablar hecho, voy a hacer los cambios apropiados, en primer lugar gracias por los comentarios de antemano! ! !

  ¿Cuál es la reflexión?

   Es un código de bytes reflexión archivos de clase se pueden reflejar en los contenidos de los campos de información, métodos y otros métodos de construcción, la invocación del método objeto también puede crear, llamamos a la reflexión técnica.

  Cómo obtener el objeto Class por la reflexión?

   Hay tres maneras: 1. obtener un objeto de clase con clase

                            2. Obtener el objeto de clase getClass () método

                        3. Obtener el objeto de clase a través Class.forName ( "nombre completo de la clase")

 

   Tres métodos de objeto Clase obtenidos por la reflexión: Caso

Clase c1 = ReflectionBasic. clase ; 
C2 Class = nuevo ReflectionBasic () getClass ().; 
C3 Class = Class.forName ( "reflection.getClassObject.ReflectionBasic" ); 

System.out.println (c1); 
System.out.println (c2); 
System.out.println (c3);

　El resultado:

 

 

　Nota: la Class.forName () puede ser adquirida además de su objeto Class también puede adquirirse objeto de clase se carga automáticamente en la memoria a las máquinas virtuales JVM, los resultados se pueden ver en los siguientes casos bloque de código estático estática de una salida de código genérico C4 y C5 del objeto, pero sólo la salida de la C5 estática, que ilustra el uso de la clase de objeto Class.forName () pueden ser cargados en la memoria a las máquinas virtuales JVM.

  caso:

 // la salida OtherTest objeto reflectante 
 Clase OtherTest C4 = <?>. Clase ; 
System.out.println ( "El objetivo de salida es C4 ===================== ========== "+ C4); 
Clase C5 = la Class.forName (<?>" reflection.getClassObject.OtherTest " ); 
System.out.println ( " el objetivo de salida es C5 ==== =========================== "+ c4);

{OtherTest clase 
    estática { 
        System.out.println ( "¿Estás bien !!! bebés !!!"); 
    } 
}

   El resultado:

 

 

  La obtención de información que refleja la clase

  Hay muchos tipos de información se refleja en Bolsas java.lang.reflect

  información de clase de la reflejada

  Tipo de interfaz:

pública  interfaz IReflection { 
}

  Clase de Padres:

público  de clase Reflexión { 
}

  categorías principales:

público  de clase ReflectionInfo la extiende la reflexión los implementos IReflection {
     públicas  estáticas  void main (String [] args) {
         // crear una clase de objeto 
        de la clase C1 = ReflectionInfo <?>. clase ;
         // Obtener Clase ======== refleja ReflectionInfo ======================== modificadoras 
        int modificadores = c1.getModifiers (); // GET es un número entero entonces tenemos que convertir el 
        sistema. out.println (modificadores); 
        cadena sModifiers = Modifier.toString (modificadores); // información convertida obtenida 
        System.out.println (sModifiers); 
        System.out.println ("Se trata de obtener lo anterior reflexión ReflectionInfo clase ================================ modificador" );
         // se reflejan ReflectionInfo ================================ nombre completo de la clase de la clase 
        string name = c1.getName (); 
        System.out. el println (nombre); 
        // Obtener ================================ simple reflejo ReflectionInfo nombre de la clase clase 
        de cuerdas simpleName = c1.getSimpleName (); 
        System.out.println (SimpleName); 
        System.out.println ( "adquisición de clase alta ===================== reflexión ReflectionInfo =========== nombre completo de la clase y el nombre de la clase simple " );
         // obtener ======================= clase ReflectionInfo reflexión ========= el nombre completo de la clase padre 
        de clase para la superclase = <?> c1.getSuperclass (); 
        System.out.println (superclass.getSuperclass ()); 
        // Obtener Clase ============================== refleja ReflectionInfo sencillo nombre de la clase padre == 
        System.out.println (superclass.getSimpleName ()); 
        System.out.println ( "adquisición de clase alta ================= ReflectionInfo reflexión =============== nombre completo de la clase padre y la sencillez de los padres nombre de la clase " );
         // obtener ================= clase ReflectionInfo reflexión =============== las interfaces, porque necesitamos la interfaz puede ser una pluralidad de salidas a cabo por la que atraviesa 
        Clase [] = las interfaces <?> c1.getInterfaces ();
         IF (interfaces.length> 0 ) {
             a ( int i = 0; I <interfaces.length; I ++ ) {
                 // Obtener clase ======================== reflejado ReflectionInfo ======== nombre de la interfaz completa
                System.out.println (las interfaces [I]);
                 // Obtener Clase =============================== reflejado ReflectionInfo nombre simple interface = 
                System.out.println (las interfaces [I] .getSimpleName ()); 
            } 
        } 
    } 
}

El resultado:

 

 

El acceso de campo de la tecnología de reflexión (sub-modificado públicas y privadas)

Error de caso: obtener el valor de la propiedad privada por el método getFile (), se quejará

público  de clase AccessFiled {
     públicas  estáticas  vacíos principales (args String []) lanza un NoSuchFieldException, IllegalAccessException, InstantiationException {
         // crear objetos de la clase 
        C1 Clase Empresa = <?>. clase ;
         // Volver al campo de público pública 
        Campo, Campo, = c1.getField ( "nombre" );
         // crear una instancia de un objeto mediante la técnica de reflexión, llamados por constructor predeterminado sin argumentos Oh 
        objeto obj = c1.newInstance (); // este método es equivalente a un nuevo objeto de empresa 
        field.set (obj, "compañía desconocida" );   // establecer el valor de campo de nombre 
        System.out.println (obj); 
        System.out.println (Field.get (obj));// valor del campo nombre de salida 

        // Devolver campos públicos pública 
        campo, campos c1.getField = ( "ID" );
         // crear una instancia de un objeto mediante la técnica de reflexión, llamados por constructor predeterminado sin argumentos oh 
        field.set (obj, "00001 ");   // establecer el valor de nombre de campo 
        System.out.println (Field.get (obj)); // nombre de salida valor del campo 

    } 
} 
la clase de su empresa {
     público String nombre;
     privada  int ID; 
}

El resultado:

 

caso apropiado: utilización método para obtener getDeclaredField () modificado privada valor id, esto puede llegar a cualquier modificador de campo modificado

   

público  de clase AccessFiled {
     públicas  estáticas  vacíos principales (args String []) lanza un NoSuchFieldException, IllegalAccessException, InstantiationException {
         // crear objetos de la clase 
        C1 Clase Empresa = <?>. clase ;
         // Volver al campo de público pública 
        Campo, Campo, = c1.getField ( "nombre" );
         // crear una instancia de un objeto mediante la técnica de reflexión, llamados por constructor predeterminado sin argumentos Oh 
        objeto obj = c1.newInstance (); // este método es equivalente a un nuevo objeto de empresa 
        field.set (obj, "compañía desconocida" );   // establecer el valor de campo de nombre 
        System.out.println (obj); 
        System.out.println (Field.get (obj));// valor del campo nombre de salida 

        // Devolver campos públicos pública 
        campo, campos c1.getDeclaredField = ( "ID" );
         // crear una instancia de un objeto mediante la técnica de reflexión, llamados por constructor predeterminado sin argumentos oh 
        field.set (obj, "00001 ");   // establecer el valor de nombre de campo 
        System.out.println (Field.get (obj)); // nombre de salida valor del campo 

    } 
} 
la clase de su empresa {
     público String nombre;
     privada  int ID; 
}

El resultado:

 

método de llamada reflejada por la técnica

público  de clase callobject {
     públicas  estáticas  void main (String [] args) lanza un NoSuchMethodException, IllegalAccessException, un InstantiationException es, un InvocationTargetException {
         // Crear objeto de clase 
        de la clase C1 = Empresa <?>. clase ;
         // método reflexivo Shou () 
        Método Método = c1. getMethod ( "Mostrar", nula ); // delante del argumento es el nombre del método. El último método es el tipo de valor de retorno
         // por reflexión para crear instancias 
        de objetos obj = c1.newInstance (); 
        System.out.println ( "sin parámetros ===========" + method.invoke (obj , nula ));
        System.out.println (obj); 
        método, shous = c1.getMethod ( "muestra", de cadena. Clase ); 
        shous.invoke (obj, "Company desconocido" );
         // Shows reflectantes () con (lista de parámetros Type) 
        System.out.println ( "referencia tiene ===========" + obj) ;; 
    } 
} 
la clase de su empresa {
     público String nombre;
     privada  int ID; 

    pública  vacío Show () { 
        System.out.println ( "Mostrar ===== método" ); 
    } 
    públicos  vacíos muestra (String nombre) { 
        System.out.println ( "muestra" método ====== );
         el este .name = nombre; 
    } 



    @ Override 
    pública Cadena toString () {
         retorno "de la empresa {" + 
                "name =" '+ nombre + '\'' + 
                "id =" + ID + 
                '}' ; 
    } 
}

El resultado:

 

 

  la reflexión de Java para explicar la base se completa, que no saben o no entienden, puedo dar un mensaje en la sección de comentarios, voy a responder con prontitud a todo el mundo.