Java-Reflexionsmechanismus

Wenn das Programm ausgeführt wird, darf sich die Programmstruktur oder der Variablentyp ändern. Diese Sprache wird als dynamische Sprache bezeichnet. Wir glauben, dass Java keine dynamische Sprache ist, aber über einen sehr wichtigen dynamischen Mechanismus verfügt, der allgemein als Reflexion bekannt ist.

In der IT-Branche heißt es, dass es ohne Reflexion kein Framework gäbe. Die bestehenden Frameworks basieren alle auf Reflexion. In der tatsächlichen Projektentwicklung werden Frameworks am häufigsten verwendet und Klassen werden am häufigsten ausgefüllt. Das Konzept der Reflexion ist der Vermittler, der Frameworks und Klassen kombiniert. Daher ist Reflexion das Sprungbrett, um mit der Projektentwicklung in Kontakt zu treten!

Was ist der Reflexionsmechanismus?

Der Reflexionsmechanismus ist im laufenden Zustand und kann alle Attribute kennen Attribute dieser Klasse; für jedes Objekt können alle seine Methoden und Eigenschaften aufgerufen werden; die Funktion zum dynamischen Aufrufen der Methoden des Objekts wird als Reflexionsmechanismus der Java-Sprache bezeichnet.

Was der Reflexionsmechanismus leisten kann

Der Reflexionsmechanismus bietet hauptsächlich die folgenden Funktionen:

• Bestimmen Sie die Klasse, zu der ein Objekt zur Laufzeit gehört

• Konstruieren Sie zur Laufzeit ein Objekt einer beliebigen Klasse; >

  Beurteilen Sie die Mitgliedsvariablen und Methoden einer beliebigen Klasse zur Laufzeit.

• Rufen Sie die Methode eines beliebigen Objekts zur Laufzeit auf dynamischer Proxy.
Spezifische Funktionsimplementierung

• 1. Es gibt drei Möglichkeiten, die Klasse über den Reflexionsmechanismus zu erhalten

2. Erstellen Sie ein Objekt: Nachdem wir die Klasse erhalten haben, erstellen wir ihr Objekt mit newInstance:

3. Holen Sie sich die Attribute: aufgeteilt in alle Attribute und angegebenen Attribute:

Sehen Sie sich zunächst an, wie Sie alle Attribute erhalten:

//第一种方式：  
Classc1 = Class.forName("Employee");  
//第二种方式：  
//java中每个类型都有class 属性.  
Classc2 = Employee.class;  
   
//第三种方式：  
//java语言中任何一个java对象都有getClass 方法  
Employeee = new Employee();  
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)

Erhalten Sie spezifische Attribute und lernen Sie durch den Vergleich mit herkömmlichen Methoden:

Class c =Class.forName("Employee");  
  
//创建此Class 对象所表示的类的一个新实例  
Objecto = c.newInstance(); //调用了Employee的无参数构造方法.

Methodenreflexion

//获取整个类  
            Class c = Class.forName("java.lang.Integer");  
              //获取所有的属性?  
            Field[] fs = c.getDeclaredFields();  
       
                   //定义可变长的字符串，用来存储属性  
            StringBuffer sb = new StringBuffer();  
            //通过追加的方法，将每个属性拼接到此字符串中  
            //最外边的public定义  
            sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
            //里边的每一个属性  
            for(Field field:fs){  
                sb.append("\t");//空格  
                sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等  
                sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字  
                sb.append(field.getName()+";\n");//属性的名字+回车  
            }  
      
            sb.append("}");  
      
            System.out.println(sb);

public static void main(String[] args) throws Exception{  
              
<span style="white-space:pre">  </span>//以前的方式：  
    /* 
    User u = new User(); 
    u.age = 12; //set 
    System.out.println(u.age); //get 
    */  
              
    //获取类  
    Class c = Class.forName("User");  
    //获取id属性  
    Field idF = c.getDeclaredField("id");  
    //实例化这个类赋给o  
    Object o = c.newInstance();  
    //打破封装  
    idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。  
    //给o对象的id属性赋值"110"  
    idF.set(o, "110"); //set  
    //get  
    System.out.println(idF.get(o));  
}

Die Class-Klasse hat die einfachste Methode, getName():

Die getName-Methode kann den Klassennamen des Klassentyps ausdrucken. Das können wir auch Mit der Methode getSimpleName() kann der Name der Klasse ohne den Paketnamen ausgegeben werden. Wie aus dem obigen Code ersichtlich ist, sind in Klassentypen alle grundlegenden Datentypen und void-Schlüsselwörter vorhanden.

Fall:

Zusammenfassungsidee:

public class Demo2 {
public static void main(String[] args) {
Class c1 = int.class;//int 的类类型
Class c2 = String.class;//String类的类类型
Class c3 = void.class;
System.out.println(c1.getName());
System.out.println(c2.getName());
System.out.println(c2.getSimpleName());
System.out.println(c3.getName());
}
}

Ermitteln Sie den Namen der Klasse durch Methodenreflexion. Schritte:

Ermitteln Sie den Klassentyp der Klasse.

2. Holen Sie sich die Methode der Klasse über den Klassentyp (getMethods())

3. Durchlaufen Sie die erhaltenen Methoden

4. Holen Sie sich den Klassentyp des Rückgabewerttyps über getReturnType() dieser Methoden und Holen Sie sich dann den Klassentyp über den Klassentyp. Der Name des Rückgabewerttyps

public class ClassUtil {
public static void printClassMethodMessage(Object obj){
//要获取类的信息》》首先我们要获取类的类类型
Class c = obj.getClass();
//我们知道Object类是一切类的父类，所以我们传递的是哪个子类的对象，c就是该子类的类类型。
//接下来我们要获取类的名称System.out.println("类的名称是:"+c.getName());
/*
*我们知道，万事万物都是对象，方法也是对象，是谁的对象呢？
* 在java里面，方法是Method类的对象
*一个成员方法就是一个Method的对象，那么Method就封装了对这个成员
*方法的操作
*///如果我们要获得所有的方法，可以用getMethods()方法，这个方法获取的是所有的Public的函数，包括父类继承而来的。如果我们要获取所有该类自己声明的方法，就可以用getDeclaredMethods()方法，这个方法是不问访问权限的。
Method[] ms = c.getMethods();//c.getDeclaredMethods()
//接下来我们拿到这些方法之后干什么？我们就可以获取这些方法的信息，比如方法的名字。
//首先我们要循环遍历这些方法
for(int i = 0; i < ms.length;i++){
//然后可以得到方法的返回值类型的类类型
Class returnType = ms[i].getReturnType();
//得到方法的返回值类型的名字
System.out.print(returnType.getName()+" ");
//得到方法的名称
System.out.print(ms[i].getName()+"(");
//获取参数类型--->得到的是参数列表的类型的类类型
Class[] paramTypes = ms[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}

5.getName() ruft den Namen der Methode ab und getParameterTypes() ruft den Klassentyp des Parametertyps in dieser Methode ab.

Reflexion von Mitgliedsvariablen

Zuerst müssen wir erkennen, dass Mitgliedsvariablen auch Objekte und java.lang sind .reflect .Field-Klassenobjekt, das heißt, die Field-Klasse kapselt die Operationen an Mitgliedsvariablen. Wie erhalten wir diese Mitgliedsvariablen, da es Mitgliedsvariablen kapselt? Es gibt eine solche Methode: Die Methode getFields() ruft hier die Informationen aller öffentlichen Mitgliedsvariablen ab. Und die öffentlichen Mitgliedsvariablen in der Reflexionsmethode enthalten auch Informationen zu allen selbst deklarierten Mitgliedsvariablen:

Nachdem wir sie erhalten haben, können wir sie durchlaufen (da die Feldinformationen gekapselt sind). Dann wir (kann den Feldtyp erhalten)

public class ClassUtil {
public static void printFieldMessage(Object obj){
Class c = obj.getClass();
//Field[] fs = c.getFields();
}

Konstruktorreflexion

Field[] fs = c.getDeclaredFields();

Ob es sich um Methodenreflexion, Mitgliedsvariablenreflexion oder Konstruktorreflexion handelt, wir Alles was Sie wissen müssen ist : Wenn Sie Informationen zu einer Klasse erhalten möchten, müssen Sie zunächst den Klassentyp der Klasse ermitteln.

for (Field field : fs) {
//得到成员变量的类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getName();
//得到成员变量的名称
String fieldName = field.getName();
System.out.println(typeName+" "+fieldName);
}