réflexion Java de la technologie sous-jacente

 Aujourd'hui, je vous explique la technologie de base de réflexion Java, en cas d'erreur ou mauvais peut être beaucoup parler fait, je vais faire les changements appropriés, d'abord vous remercier pour les commentaires à l'avance! ! !

  Quelle est la réflexion?

   Il est un fichier de classe bytecode de réflexion peuvent se refléter dans le contenu des champs d'information, les méthodes et les autres méthodes de construction, l'appel de méthode d'objet peut également créer, nous appelons technique de réflexion.

  Comment faire pour obtenir l'objet de classe par réflexion?

   Il y a trois façons, 1. obtenir un objet de classe avec classe

                            2. Obtenir l'objet de classe par la méthode getClass ()

                        3. Obtenir l'objet de classe par Class.forName ( « nom de classe »)

 

   Trois méthodes d'objet de classe obtenues par réflexion: cas

Classe c1 = ReflectionBasic. classe ; 
Classe c2 = nouveau ReflectionBasic () getClass (). 
Classe c3 = Class.forName ( "reflection.getClassObject.ReflectionBasic" ); 

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

　Le résultat:

 

 

　Note: l'Class.forName () peut être acquis en plus de son objet de classe peut également être acquis objet de classe est automatiquement chargée dans la mémoire aux machines virtuelles JVM, les résultats peuvent être vus dans les cas suivants bloc statique de code statique d'une sortie de code générique C4 et C5 de l'objet, mais que la sortie de la C5 statique, ce qui illustre l'utilisation de l'objet de classe Class.forName () peuvent être chargés dans la mémoire de machines virtuelles JVM.

  cas:

 // la sortie OtherTest objet réfléchissant 
 classe OtherTest C4 = <?>. Classe ; 
System.out.println ( « La cible de sortie est C4 ===================== ========== "+ C4); la 
classe C5 = la Class.forName (<?>" reflection.getClassObject.OtherTest " ); 
System.out.println ( " la cible de sortie est C5 ==== =========================== « + c4);

{OtherTest classe 
    statique { 
        System.out.println ( "Tu vas bien !!! bébés !!!"); 
    } 
}

   Le résultat:

 

 

  Obtenir des informations reflétant la classe

  Il existe de nombreux types d'informations reflétées dans Sacs java.lang.reflect

  une information de classe réfléchi

  Type d'interface:

publique  Interface IReflection { 
}

  Classe mère:

publique  classe réflexion { 
}

  Catégories principales:

publique  classe ReflectionInfo l'étend la réflexion des outils IReflection {
     publics  statiques  vides principaux (String [] args) {
         // créer une classe d'objets de 
        classe C1 = ReflectionInfo <?>. classe ;
         // Get classe ======== reflète ReflectionInfo modificateur ======================== 
        int modificateurs = c1.getModifiers (); // get est un entier , alors nous avons besoin de convertir le 
        système. out.println (modificateurs); 
        Chaîne sModifiers = Modifier.toString (modificateurs); // information convertie obtenue 
        System.out.println (sModifiers); 
        System.out.println (« Il est d'obtenir la réflexion ci - dessus ReflectionInfo classe ================================ modificateur » );
         // se reflètent ReflectionInfo ================================ nom de classe de la classe 
        String name = c1.getName (); 
        System.out. println (nom); 
        // Get ================================ simple , réflexion ReflectionInfo nom de classe de classe 
        chaîne simpleName = c1.getSimpleName (); 
        System.out.println (SimpleName); 
        System.out.println ( réflexion « d'acquisition de classe supérieure ===================== ReflectionInfo =========== nom complet de la classe et le nom de classe simple " );
         // se classe ======================= réflexion ReflectionInfo ========= le nom complet de la classe parente 
        classe pour la superclasse = <?> c1.getSuperclass (); 
        System.out.println (superclass.getSuperclass ()); 
        // Get classe ============================== reflète ReflectionInfo nom simple de la classe parent == 
        System.out.println (superclass.getSimpleName ()); 
        System.out.println ( « acquisition de classe supérieure ================= réflexion ReflectionInfo =============== nom complet du nom de la classe mère classe parente et de la simplicité " );
         // se classe ================= réflexion ReflectionInfo =============== interfaces, parce que nous avons besoin de l'interface peut être une pluralité de sorties par la traversée de 
        classe [] = les interfaces <?> c1.getInterfaces ();
         IF (interfaces.length> 0 ) {
             pour ( int i = 0; I <interfaces.length; I ++ ) {
                 // Get classe ======================== réfléchissais ReflectionInfo ======== nom complet de l' interface
                System.out.println (les interfaces [I]);
                 // Get classe =============================== réfléchissais ReflectionInfo nom simple d'interface = 
                System.out.println (les interfaces [I] .getSimpleName ()); 
            } 
        } 
    } 
}

Le résultat:

 

 

Accès par domaine de la technologie de réflexion (sous-modifié public et privé)

Erreur de cas: obtenir la valeur de la propriété privée par la méthode getFile (), se plaindra

publique  classe AccessFiled {
     publics  statiques  vides principaux (String [] args) throws une NoSuchFieldException, IllegalAccessException, InstantiationException {
         // Création d' objets de classe 
        c1 classe entreprise = <?>. classe ;
         // Retour le domaine des partenariats public du public 
        Champ, Champ, = c1.getField ( « nom » );
         // créer une instance d'objet par la technique de réflexion, appelée par le constructeur par défaut sans argument Oh 
        Object obj = c1.newInstance (); // cette méthode équivaut à un nouvel objet de la société 
        field.set (obj, « société inconnue » );   // définir le champ de nom valeur 
        System.out.println (obj); 
        System.out.println (Field.get (obj));// valeur du champ Nom de sortie 

        // retour des champs publics du public sur le 
        terrain, les champs c1.getField = ( « ID » );
         // créer une instance d'objet par la technique de réflexion, appelée par le constructeur par défaut sans argument oh 
        field.set (obj, « 00001 « );   // définir la valeur du nom du champ 
        System.out.println (Field.get (obj)); // valeur du champ nom de la sortie 

    } 
} 
classe de l' entreprise {
     publique nom de la chaîne;
     Private  int ID; 
}

Le résultat:

 

cas approprié: l' utilisation méthode getDeclaredField () pour obtenir privée modifiée identifiant, cela peut obtenir des modificateurs champ modifié

   

publique  classe AccessFiled {
     publics  statiques  vides principaux (String [] args) throws une NoSuchFieldException, IllegalAccessException, InstantiationException {
         // Création d' objets de classe 
        c1 classe entreprise = <?>. classe ;
         // Retour le domaine des partenariats public du public 
        Champ, Champ, = c1.getField ( « nom » );
         // créer une instance d'objet par la technique de réflexion, appelée par le constructeur par défaut sans argument Oh 
        Object obj = c1.newInstance (); // cette méthode équivaut à un nouvel objet de la société 
        field.set (obj, « société inconnue » );   // définir le champ de nom valeur 
        System.out.println (obj); 
        System.out.println (Field.get (obj));// valeur du champ Nom de sortie 

        // retour des champs publics du public sur le 
        terrain, les champs c1.getDeclaredField = ( « ID » );
         // créer une instance d'objet par la technique de réflexion, appelée par le constructeur par défaut sans argument oh 
        field.set (obj, « 00001 « );   // définir la valeur du nom du champ 
        System.out.println (Field.get (obj)); // valeur du champ nom de la sortie 

    } 
} 
classe de l' entreprise {
     publique nom de la chaîne;
     Private  int ID; 
}

Le résultat:

 

Procédé d'appel réfléchie par la technique

publique  classe callobject {
     publics  statiques  vides principaux (String [] args) jette un NoSuchMethodException, IllegalAccessException, un InstantiationException est un InvocationTargetException {
         // Créer un objet de classe de 
        classe C1 = Société <?>. classe ;
         // méthode réflexive Shou () 
        méthode Méthode = c1. getMethod ( « Vérifier », nULL ); // devant l'argument est le nom de la méthode. Cette dernière méthode est le type de valeur de retour
         // par la réflexion pour créer des instances 
        Object obj = c1.newInstance (); 
        System.out.println ( "aucun paramètre ===========" + method.invoke (obj , null ));
        System.out.println (obj); 
        Méthode, shous = c1.getMethod ( "affiche", String. Classe ); 
        shous.invoke (obj, "société inconnue" ;)
         // méthode de réflexion Affiche () avec (liste des paramètres Type) 
        System.out.println ( "référence a ===========" + obj) ;; 
    } 
} 
class entreprise {
     publique nom de chaîne,
     Private  int ID, du 

    public  vide Show () { 
        System.out.println ( "Afficher ===== méthode" ); 
    } 
    publics  vides Shows (String name) { 
        System.out.println ( "méthode montre ======" ),
         le présent .name = nom; 
    } 



    @Override 
    publique String toString () {
         retour "Société {" + 
                "name = '+ nom + '\'' + 
                " id =" + id + 
                '}' ; 
    } 
}

Le résultat:

 

 

  réflexion Java pour expliquer la base est terminée, ils ne savent pas ou ne comprennent pas, je peux donner un message dans la section des commentaires, je vais répondre rapidement à tout le monde.