1. Qu'est-ce que la réflexion?
Une classe a plusieurs composants, tels que les variables membre, les méthodes, les constructeurs, etc.
La réflexion consiste à charger la classe et à disséquer les différents composants de la classe.
2. Chargement de la classe
Il y a une classe de classe en Java qui représente le bytecode d'une certaine classe.
Étant donné que la classe de classe représente le bytecode d'une certaine classe, elle doit fournir un chargement d'une certaine classe.
Méthode de bytecode: forname ().
dans la mémoire et encapsuler à l'aide d'objets de classe.
Deux autres façons d'obtenir des objets de classe:
Nom de la classe. CLASSE
Object.getClass ()
Créez d'abord une classe de personne simple
La copie de code est la suivante:
classe publique ReflectDemo {
public static void main (String args []) lève une exception
{// 1.
Class Clazz = class.forname ("dsa.person");
// 2.
Classe Cllazz1 = new Person (). GetClass ();
// 3.
Classclazz2 = personne.classe;
}
}
3. Méthode de construction de réflexion
En classe de personne:
La copie de code est la suivante:
/ **
* Méthode de construction
* /
publicPerson () {
System.out.println ("null");
}
publicSerson (StringName) {
System.out.println (nom);
}
publicPerson (stringName, intpwd) {
System.out.println (nom + "+" + pwd);
}
PrivateSerson (listList) {
System.out.println ("liste");
}
Dans la classe de test:
La copie de code est la suivante:
// Reflection PublicSerson ()
@Test
publicVoidTest1 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
Constructorcr = Clazz.getConstructor (null); // Obtenez l'objet constructeur
Personp = (personne) cr.newinstance (null); // instancier l'objet via le constructeur
//System.out.println(p.name);
}
// Réflexion publique (StringName)
@Test
publicVoidTest2 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
ConstructorCr = Clazz.getConstructor (String.class);
Personp = (personne) cr.newinstance ("haha");
System.out.println (P.Name);
}
// Réflexion publique (StringName, Intpwd)
@Test
publicVoidTest3 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
ConstructorCr = Clazz.getConstructor (String.class, int.class);
Personp = (personne) cr.newinstance ("haha", 1);
//System.out.println(p.name);
}
// Réflexion publique (listList)
@Test
publicVoidTest4 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
ConstructorCr = Clazz.getDeclaredConstructor (list.class);
cr.setaccessible (true); // fissure de force brute
PersonP = (personne) cr.newinstance (newArrayList ());
System.out.println (P.Name);
}
// Une autre façon de créer des objets ne s'applique qu'à la construction de méthodes sans paramètres
@Test
publicVoidTest5 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
Personp = (personne) Clazz.newinstance ();
System.out.println (P.Name);
}
Lorsque la méthode de construction est privée, nous ferons une fissure brute! ! !
4. Méthodes de réflexion conventionnelles
En classe de personne:
La copie de code est la suivante:
/ **
*méthode
* /
publicVoidjf ()
{
}
publicVoidjf (StringName, Intpwd)
{
}
publicClass [] jf (StringName, int [] pwd)
{
returnNewClass [] {string.class, int.class};
}
privateVoidjf (inputStreamin)
{
System.out.println (in);
}
publicStaticVoidjf (intnum)
{
System.out.println (num);
}
publicStaticVoidMain (StringArgs [])
{
System.out.println ("Main !!!");
}
Dans la classe de test:
La copie de code est la suivante:
/ **
* Méthode de réflexion
*
* @ authortanlvxu
*
* /
publicClassDemo2 {
// Méthode de la classe de réflexion: publicVoidjf ()
@Test
publicVoidTest1 () ThrowSException {
PersonP = newPerson ();
Classclazz = class.forname ("rflectorDemo.person");
MethodMethod = Clazz.getMethod ("jf", null);
Method.invoke (p, null);
}
// Méthode de la classe de réflexion: publicVoidjf (StringName, intpwd)
@Test
publicVoidTest2 () ThrowSException {
PersonP = newPerson ();
Classclazz = class.forname ("rflectorDemo.person");
MethodMethod = Clazz.getMethod ("jf", string.class, int.class);
Method.invoke (P, "DSA", 30);
}
// Méthode de la classe de réflexion: publicClass [] jf (StringName, int [] pwd)
@Test
publicVoidTest3 () ThrowSException {
PersonP = newPerson ();
Classclazz = class.forname ("rflectorDemo.person");
MethodMethod = Clazz.getMethod ("JF", String.class, int []. Classe);
Classcs [] = (class []) method.invoke (p, "aads", newint [] {1,2,3});
System.out.println (cs [0]);
}
// Méthode de la classe de réflexion: privatevoidjf (inputStreamin)
@Test
publicVoidTest4 () ThrowSException {
PersonP = newPerson ();
Classclazz = class.forname ("rflectorDemo.person");
MethodMethod = Clazz.getDeclaredMethod ("JF", InputStream.class);
Method.SetAccessible (true);
méthode.invoke (p, newFileInputStream ("d: //qqclient.txt"));
}
// Méthode de la classe de réflexion: publicstatinvoidjf (intnum)
@Test
publicVoidTest5 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
MethodMethod = Clazz.getMethod ("jf", int.class);
Method.invoke (null, 30);
}
// Méthode de la classe de réflexion: publicstatinvoidm (intnum)
@Test
publicVoidTest6 () ThrowSException {
Classclazz = class.forname ("rflectorDemo.person");
MethodMethod = Clazz.getMethod ("Main", String []. Class);
//method.invoke(null ,(Object)Newstring °
Method.invoke (null, newObject [] {Newstring [] {"ds", "das"}});
}
5. Champs de réflexion
En classe de personne:
La copie de code est la suivante:
/ **
*Champ
* /
PublicStRingName = "SWR";
privateIntPassword = 45;
privateStaticIngage = 35;
Dans la classe de test:
Code java
/ **
* Champs de classe réfléchissants
* @ authortanlvxu
*
* /
publicClassDemo3 {
/ **
* Reflection Field PublicStRingName = "SWR";
* @ ThrowSException
* /
@Test
publicVoidTest1 () ThrowSException
{
PersonP = newPerson ();
Classclazz = class.forname ("rflectorDemo.person");
Fieldf = Clazz.getfield ("nom");
// Obtenez la valeur du champ
ObjectValue = f.get (p);
// Obtenez le type de champ
CLASSTYPE = F.GetType ();
if (type.equals (string.class)) {
StringName = (String) f.get (p);
System.out.println (nom);
}
// Définit la valeur du champ
f.set (p, "dfafa");
System.out.println (P.Name);
}
/ **
* Field de réflexion PrivateIntPassword;
* @ ThrowSException
* /
@Test
publicVoidTest2 () ThrowsException
{
PersonP = newPerson ();
Classclazz = class.forname ("rflectorDemo.person");
Fieldf = Clazz.getDeclaredField ("mot de passe");
f.setAccessible (true);
f.set (p, 36);
System.out.println (f.get (p));
}
/ **
* Champ de réflexion privateStaticInTage = 35;
* @ ThrowSException
* /
@Test
publicVoidTest3 () ThrowSException
{
Classclazz = class.forname ("rflectorDemo.person");
Fieldf = Clazz.getDeclaredField ("âge");
f.setAccessible (true);
f.set (null, 24);
System.out.println (f.get (null));
}
En fait, peu importe la méthode de construction de réflexion ou les champs, nous pouvons en apprendre un par un!