Beispielcode-Sharing zum Reflexionsmechanismus in Java (Bild)

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.

Drittens werfen wir einen Blick auf die Klassen des Reflexionsmechanismus, den uns die Sonne bietet:

Viele Von diesen vier Klassen können wir Methoden, Eigenschaften und andere Operationen reflektierend abfragen. Oder sollten wir lernen, die API ständig abzufragen, das ist unser bester Lehrmeister.

java.lang.Class;        

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

java.lang.reflect.Method;

java.lang.reflect.Modifier;

Spezifische Funktionsimplementierung:

1. Es gibt drei Möglichkeiten, Klassen über den Reflexionsmechanismus zu erhalten

2,

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

Objekt erstellen

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

3, Attribute abrufen: unterteilt in alle Attribute und spezifizierte Attribute:

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

a, sehen Sie sich zunächst an, wie alle Attribute abgerufen werden:

b, spezifische Attribute erhalten und im Vergleich zu herkömmlichen Methoden lernen:

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

4 Die Erfassungsmethode und die Konstruktionsmethode werden nicht im Detail beschrieben, nehmen Sie einfach a Schlüsselwörter:

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

objektorientiert

implementieren.

Fünftens: Reflection plus

Konfigurationsdatei macht 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:

Reflexionsschreiben:

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

Dieser Vorteil ist, dass es sehr einfach ist und für uns praktisch, um die Datenbank zu transformieren. Wenn wir beispielsweise die Datenbank von SQL Server auf Oracle aktualisieren, schreiben wir zwei D-Schichten, ändern den Inhalt der Konfigurationsdatei oder fügen Bedingungen für die Auswahl hinzu. was großen Komfort bringt.

 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!

Das obige ist der detaillierte Inhalt vonBeispielcode-Sharing zum Reflexionsmechanismus in Java (Bild). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!