Was ist der Java-Reflexionsmechanismus? So verwenden Sie den Java-Reflexionsmechanismus

Der Inhalt dieses Artikels befasst sich mit der Frage, was der Java-Reflexionsmechanismus ist. Die Methode zur Verwendung des Java-Reflexionsmechanismus hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.

Apropos Reflexionsmechanismus: Wer zum ersten Mal damit in Berührung kommt, ist möglicherweise verwirrt. Wie reflektieren? Wofür ist Reflexion? Als nächstes werde ich in diesem Artikel über die Reflexionsmaschine von Java sprechen

Aber vorher muss noch ein Problem gelöst werden: Die Dynamik im Titelnamen. Lassen Sie mich zunächst dynamische Sprache und statische Sprache vorstellen

Statische Sprache

　Statische Sprache ist Sprachen, in denen der Datentyp der Variablen zur Kompilierzeit bestimmt werden kann. Die meisten statisch typisierten Sprachen erfordern, dass der Datentyp vor der Verwendung der Variablen deklariert wird. Zum Beispiel: C++, Java, Delphi, C# usw.

Dynamische Sprache

　Eine dynamische Sprache ist eine Sprache, die Datentypen zur Laufzeit bestimmt . Vor der Verwendung einer Variablen ist keine Typdeklaration erforderlich. Normalerweise ist der Typ der Variablen der Typ des Werts, dem sie zugewiesen ist. Zum Beispiel PHP/ASP/Ruby/Python/Perl/ABAP/SQL/JavaScript/Unix Shell usw. und Dynamische Sprache bedeutet, dass das Programm seine Struktur während der Ausführung ändern kann: Es können neue Funktionen eingeführt, bestehende Funktionen gelöscht und andere strukturelle Änderungen vorgenommen werden.

Zu diesem Zeitpunkt haben Sie möglicherweise Fragen. Da Java eine statische Sprache ist, wie kann sie dynamisch sein? Durch den Reflexionsmechanismus kann Java während der Kompilierung des Programms völlig unbekannte Klassen laden, erkennen und verwenden und zugehörige Klassenobjektinstanzen generieren, sodass seine Methoden aufgerufen werden können oder ein bestimmter Attributwert angegeben werden kann geändert. JAVA kann also auch als semidynamische Sprache betrachtet werden

Lassen Sie uns über den Reflexionsmechanismus sprechen

　Konzept des Reflexionsmechanismus Der Reflexionsmechanismus in Java bedeutet, dass jede Klasse im laufenden Zustand alle Eigenschaften und Methoden dieser Klasse kennen kann Objekt, jede seiner Methoden kann aufgerufen werden; diese Funktion zum dynamischen Abrufen von Informationen und zum dynamischen Aufrufen von Objektmethoden wird als Reflexionsmechanismus der Java-Sprache bezeichnet.

Das Prinzip der Reflexion liegt im Klassenobjekt

Schauen Sie sich das an Prozess des Programmladens

Auf dem Bild können Sie wahrscheinlich erkennen, wofür Reflexion verwendet wird, dann lassen Sie uns über andere Aspekte der Reflexion sprechen

　

Reflection API

　 Die Reflection API wird verwendet, um Informationen über Klassen, Schnittstellen oder Objekte in der JVM zu generieren.

　 -
Klassenklasse: Die Kernklasse der Reflexion, die die Attribute, Methoden und andere Informationen der Klasse abrufen kann. 　 -
Feldklasse: Eine Klasse im Paket Java.lang.reflec, die die Mitgliedsvariablen der Klasse darstellt und zum Abrufen und Festlegen von Attributwerten in der Klasse verwendet werden kann. 　 -
Methodenklasse : Eine Klasse im Java.lang.reflec-Paket, die die Methode der Klasse darstellt. Sie kann verwendet werden, um Methodeninformationen abzurufen oder Methoden in der Klasse auszuführen. 　 –
Konstruktorklasse: Eine Klasse im Java.lang.reflec-Paket, die die Konstruktionsmethode der Klasse darstellt.

Lassen Sie uns darüber sprechen, wie man Reflexion nutzt　　

1. Schritte

• Rufen Sie das Class-Objekt der Klasse ab, die Sie bedienen möchten

• Rufen Sie die Methode in der Class-Klasse auf

• Verwenden Sie die Reflection-API, um diese Informationen zu verarbeiten

2. Methode zum Abrufen des Klassenobjekts

//假设我们有一个Student类
方法一、(推荐)
    Class clas = Class.forName("first.Student");//“”里写的是类的全路径

方法二、
    Student stu = new Student();
    Class clas = stu.getClass();

方法三、
    Class clas = Student.Class;

Sie können versuchen, zwei verschiedene Methoden zu verwenden, um clas1 und clas2 zu erhalten, und dann System.ou.println(clas1==clas2), um zu sehen, was ausgegeben wird. Der Grund ist im Bild

3 . Holen Sie sich die Konstruktionsmethode, das Feld, die Hauptmethode und rufen Sie

Student.java

public class Student {
    public String name;
    protected int age;
    char sex;
    private String phoneNum;
    
    public static void main(String[] args) {

        System.out.println("main方法执行了。。。");

    }
    //---------------构造方法-------------------
    Student(String str) {
        System.out.println("(默认)的构造方法 s = " + str);
    }

    // 无参构造方法
    public Student() {
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }

    // 有一个参数的构造方法
    public Student(char name) {

        System.out.println("姓名：" + name);
    }

    // 有多个参数的构造方法
    public Student(String name, int age) {
        this.name=name;this.age=age;
        System.out.println("姓名：" + name + "年龄：" + age);// 这的执行效率有问题，以后解决。
    }

    // 受保护的构造方法
    protected Student(boolean n) {
        System.out.println("受保护的构造方法 n = " + n);
    }

    // 私有构造方法
    private Student(int age) {
        System.out.println("私有的构造方法   年龄：" + age);
    }
    
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex
                + ", phoneNum=" + phoneNum + "]";
    }
}

auf

Constructors.java（构造方法）

package first;

import java.lang.reflect.Constructor;

public class Constructors {
    public static void main(String[] args) throws Exception {
        
        Class clas=Class.forName("first.Student");
        
        System.out.println("所有公有构造方法");
        Constructor[] conArry=clas.getConstructors();
        for(int i=0;i<conArry.length;i++) {
            System.out.println(conArry[i]);
        }
        
        System.out.println("所有的构造方法");
        conArry=clas.getDeclaredConstructors();
        for(int i=0;i<conArry.length;i++) {
            System.out.println(conArry[i]);
        }
        
        System.out.println("获取公有无参的构造方法");
        Constructor con=clas.getConstructor(null);
        System.out.println("con="+con);
        Object obj=con.newInstance();
        
        System.out.println("获取私有构造方法，并调用");
        con=clas.getDeclaredConstructor(char.class);
        System.out.println(con);
        //con.setAccessible(true);//暴力访问，针对private方法和字段时使用
        obj=con.newInstance(&#39;a&#39;);//创建对象
    }
}

输出

所有公有构造方法
public first.Student(char)
public first.Student()
public first.Student(java.lang.String,int)
所有的构造方法
protected first.Student(boolean)
private first.Student(int)
public first.Student(char)
public first.Student()
first.Student(java.lang.String)
public first.Student(java.lang.String,int)
获取公有无参的构造方法
con=public first.Student()
调用了公有、无参构造方法执行了。。。
获取私有构造方法，并调用
public first.Student(char)
姓名：a

Fields.java（字段）

package first;
import java.lang.reflect.Field;
public class Fields {
    public static void main(String[] args)throws Exception {
        // TODO Auto-generated method stub
        Class StuClass=Class.forName("first.Student");
        
        System.out.println("获取所有公有的字段");
        Field[] fieldArry=StuClass.getFields();
        for(Field f:fieldArry) {
            System.out.println(f);
        }
        System.out.println("获取所有的字段(包括私有、受保护、默认的)");
        fieldArry=StuClass.getDeclaredFields();
        for(Field f:fieldArry) {
            System.out.println(f);
        }
        System.out.println("获取公有字段并调用");
        Field f = StuClass.getField("name");
        System.out.println(f);
        Object obj=StuClass.getConstructor().newInstance();
        StuClass.getConstructor(String.class,int.class).newInstance("a",10);
        f.set(obj, "b");
        Student stu=(Student)obj;
        System.out.println(stu.name);
        
        System.out.println("获取私有字段并调用");
        f = StuClass.getDeclaredField("phoneNum");
        System.out.println(f);
        f.setAccessible(true);//暴力反射，解除私有限定
        f.set(obj, "18888889999");
        System.out.println("验证电话：" + stu);
    }
}

输出

获取所有公有的字段
public java.lang.String first.Student.name
获取所有的字段(包括私有、受保护、默认的)
public java.lang.String first.Student.name
protected int first.Student.age
char first.Student.sex
private java.lang.String first.Student.phoneNum
获取公有字段并调用
public java.lang.String first.Student.name
调用了公有、无参构造方法执行了。。。
姓名：a年龄：10
b
获取私有字段并调用
private java.lang.String first.Student.phoneNum
验证电话：Student [name=b, age=0, sex=

Main.java

package first;
import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) {
        try {
            // 1、获取Student对象的字节码
            Class clazz = Class.forName("first.Student");

            // 2、获取main方法

            Method methodMain = clazz.getMethod("main", String[].class);// 第一个参数：方法名称，第二个参数：方法形参的类型，

            // 3、调用main方法
            // methodMain.invoke(null, new String[]{"a","b","c"});
            // 第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组
            // 这里拆的时候将 new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
            methodMain.invoke(null, (Object) new String[] {});// 方式一
            // methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Das obige ist der detaillierte Inhalt vonWas ist der Java-Reflexionsmechanismus? So verwenden Sie den Java-Reflexionsmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!