Detaillierte Erläuterung von Beispielen für Reflexionsmechanismen in Java

In diesem Artikel werden hauptsächlich relevante Informationen zur detaillierten Erklärung des Reflexionsmechanismus in Java vorgestellt. Freunde, die sie benötigen, können sich auf

Detaillierte Erklärung des Reflexionsmechanismus in Java beziehen

Reflexion: Ich habe sie oft sagen hören, dass ich einige Informationen gelesen und sie möglicherweise im Designmuster verwendet habe, aber ich hatte das Gefühl, dass ich kein tiefes Verständnis davon hatte, als ich sie studierte Auch dieses Mal hatte ich das Gefühl, dass es in Ordnung war.

Werfen wir zunächst einen Blick auf das Konzept der Reflexion:

Bezieht sich hauptsächlich auf die Fähigkeit eines Programms, auf seinen eigenen Status oder sein eigenes Verhalten zuzugreifen, ihn zu erkennen und zu ändern. und um den Status und die Ergebnisse seines eigenen Verhaltens anzupassen oder zu ändern, um den Status und die zugehörige Semantik des von der Anwendung beschriebenen Verhaltens anzupassen oder zu ändern.

Reflection ist ein leistungsstarkes Tool in Java, mit dem wir auf einfache Weise flexiblen Code erstellen können, der zur Laufzeit zusammengestellt werden kann, ohne dass eine Quellcodeverknüpfung zwischen Komponenten erforderlich ist. Doch der unsachgemäße Einsatz von Reflexion kann sehr kostspielig sein!

Wenn Sie das Konzept verwirrt, lesen Sie weiter.

2. Die Rolle des Reflexionsmechanismus:

1. Dekompilieren: .class-->.java

2 Reflexionsmechanismus Java-Objektattribute, Konstruktionsmethoden usw.; Schauen wir uns an, wie diese Funktionen im Detail implementiert werden.

java.lang.Class;        

java.lang.reflect.Constructor; java.lang.reflect.Field;    

java.lang.reflect.Method;

java.lang.reflect.Modifier;

1. Der Reflexionsmechanismus bietet drei Möglichkeiten, den Mitarbeitertyp zu erhalten

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

: Nachdem wir die Klasse erhalten haben, erstellen wir ihr Objekt, verwenden newInstance:

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

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

//获取整个类
  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));
}

Auf diese Weise können wir verschiedene Inhalte der Klasse erhalten und sie dekompilieren. Bei einer Sprache wie JAVA, die zuerst kompiliert und dann ausgeführt wird, kann der Reflexionsmechanismus den Code flexibler und einfacher

implementieren.

die Konfigurationsdatei unser Programm flexibler: Beim Erlernen von Designmustern und beim Erlernen abstrakter Fabriken war Reflection mehr daran gewöhnt Es ist praktisch, Datenbankverbindungszeichenfolgen usw. zu lesen. Da ich es damals noch nicht ganz verstand, habe ich es einfach kopiert. Schauen Sie sich die Verwendung von Reflection + Konfigurationsdateien in .NET an:

Die damals verwendete Konfigurationsdatei war die Datei app.config, der Inhalt war im XML-Format und der Inhalt der Linkdatenbank war ausgefüllt:

   <configuration>
  <appSettings>
  <add   key="" value=""/>
  </appSettings>
      </configuration>

 assembly.load("当前程序集的名称").CreateInstance("当前命名空间名称".要实例化的类名);

Natürlich gilt das Gleiche auch in JAVA, außer dass die Konfigurationsdatei hier .properties ist, die als Eigenschaftendatei bezeichnet wird. Lesen Sie den darin enthaltenen Inhalt durch Reflexion. Auf diese Weise ist der Code festgelegt, aber wir können den Inhalt der Konfigurationsdatei ändern, was unseren Code viel flexibler macht!

Zusammenfassend lässt sich sagen, dass das erneute Erlernen und die flexible Verwendung von JAVA Reflection unseren Code flexibler machen kann, aber auch seine Nachteile aufweist, d. h. die Verwendung verringert die Leistung und erhöht die Komplexität unserer Software Wir müssen es vorsichtig nutzen.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Beispielen für Reflexionsmechanismen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!