Was ist Reflexion in Java?

In Java bezieht sich Reflexion hauptsächlich auf die Fähigkeit eines Programms, auf seinen eigenen Zustand oder sein eigenes Verhalten zuzugreifen, ihn zu erkennen und zu ändern. Die Hauptfunktionen des Java-Reflexionsmechanismus: 1. Bestimmen Sie die Klasse, zu der ein Objekt zur Laufzeit gehört. 2. Konstruieren Sie ein Objekt einer beliebigen Klasse zur Laufzeit. 3. Rufen Sie die Methode eines beliebigen Objekts zur Laufzeit auf.

Die Betriebsumgebung dieses Tutorials: Windows7-System, Java8-Version, DELL G3-Computer.

Was ist Reflexion?

Bezieht sich hauptsächlich auf die Fähigkeit eines Programms, auf seinen eigenen Zustand oder sein eigenes Verhalten zuzugreifen, ihn zu erkennen und zu ändern.

Java-Reflexion?

Können Sie in der Java-Laufzeitumgebung für jede Klasse wissen, welche Attribute und Methoden diese Klasse hat? Kann für jedes Objekt eine seiner Methoden aufgerufen werden? Der Java-Reflexionsmechanismus bietet hauptsächlich die folgenden Funktionen:

　* 1. Bestimmen Sie die Klasse, zu der ein Objekt zur Laufzeit gehört.

　* 2. Konstruieren Sie zur Laufzeit ein Objekt einer beliebigen Klasse.

　* 3. Bestimmen Sie die Mitgliedsvariablen und Methoden einer beliebigen Klasse zur Laufzeit.

　* 4. Rufen Sie die Methode eines beliebigen Objekts zur Laufzeit auf.

Reflectio

Reflection ist eine Schlüsseleigenschaft von Java, da es als dynamische (oder quasi-dynamische) Sprache betrachtet wird.

Dieser Mechanismus ermöglicht es dem Programm, zur Laufzeit die internen Informationen jeder Klasse mit einem bekannten Namen über die Reflection-APIs abzurufen.

Enthält alle Informationen zu seinen Modifikatoren (z. B. öffentlich, statisch usw.), seiner Superklasse (z. B. Objekt), seinen implementierten Schnittstellen (z. B. Serialisierbar) sowie seinen Feldern und Methoden und kann den Inhalt von Feldern oder ändern Rufen Sie Methoden zur Laufzeit auf.

Dynamische Sprache

　Die Definition einer dynamischen Sprache „Wenn ein Programm ausgeführt wird, ist es erlaubt, die Programmstruktur oder den Variablentyp zu ändern. Diese Sprache wird als dynamische Sprache bezeichnet.“

　Aus dieser Sicht sind Perl, Python und Ruby dynamische Sprachen, während C++, Java und C# keine dynamischen Sprachen sind.

Obwohl Java gemäß dieser Definition und Klassifizierung keine dynamische Sprache ist, verfügt es über einen sehr wichtigen dynamischen Mechanismus: Reflexion. Dieses Wort bedeutet: Reflexion, Bild, Reflexion. Wenn es in Java verwendet wird, bedeutet es, dass wir zur Laufzeit Klassen laden, erkennen und verwenden können, die während der Kompilierung völlig unbekannt sind.

　Mit anderen Worten: Ein Java-Programm kann eine Klasse laden, deren Name nur zur Laufzeit bekannt ist, ihre vollständige Struktur (jedoch ohne Methodendefinitionen) lernen und ihre Objektentität generieren oder Werte für ihre Felder festlegen oder aufrufen seine Methoden.

　 Diese Fähigkeit des Programms, sich selbst zu untersuchen, wird Introspektion (Introspektion, Introspektion, Introspektion) genannt. Reflexion und Selbstbeobachtung sind zwei Begriffe, die oft zusammen erwähnt werden.

Einführung in die Java Reflection API

Im JDK wird der Java Reflection-Mechanismus hauptsächlich durch die folgenden Klassen implementiert. Diese Klassen (außer der ersten) befinden sich alle im Paket java.lang.reflect

: stellt eine Klasse dar, die sich im Paket java.lang befindet.

　Feldklasse: Stellt die Mitgliedsvariablen der Klasse dar (Mitgliedsvariablen werden auch als Attribute der Klasse bezeichnet).

　Methodenklasse: Stellt die Methode der Klasse dar.

Konstruktorklasse: Stellt die Konstruktionsmethode der Klasse dar.

　 Array-Klasse: Bietet statische Methoden zum dynamischen Erstellen von Arrays und zum Zugriff auf Elemente von Arrays.

Klassenobjekt

Um Reflektion zu verwenden, müssen Sie zunächst das Klassenobjekt abrufen, das der Klasse entspricht, an der gearbeitet werden soll.

Unabhängig davon, wie viele Objekte einer bestimmten Klasse in Java generiert werden, entsprechen diese Objekte demselben Klassenobjekt.

Dieses Klassenobjekt wird von der JVM generiert, wodurch die Struktur der gesamten Klasse erlernt werden kann.

Drei häufig verwendete Methoden zum Abrufen von Klassenobjekten:

1. Verwenden Sie die statische Methode der Klassenklasse. Beispiel:

Class.forName(“java.lang.String”);

2. Verwenden Sie die .class-Syntax der Klasse. Zum Beispiel:

String.class;

3. Verwenden Sie die getClass()-Methode des Objekts. Zum Beispiel:

String str = “aa”; 
Class

Routine 1: Methode abrufen Die Routine DumpMethods-Klasse demonstriert die Grundfunktion der Reflection-API. Sie liest den durch den Befehlszeilenparameter angegebenen Klassennamen und gibt dann die Methodeninformationen aus diese Klasse.

import java.lang.reflect.Method;
 
public class DumpMethods
{
    public static void main(String[] args) throws Exception //在方法后加上这句，异常就消失了
    {
        //获得字符串所标识的类的class对象
        Class<?> classType = Class.forName("java.lang.String");//在此处传入字符串指定类名，所以参数获取可以是一个运行期的行为，可以用args[0]
 
        //返回class对象所对应的类或接口中，所声明的所有方法的数组（包括私有方法）
        Method[] methods = classType.getDeclaredMethods();
 
        //遍历输出所有方法声明
        for(Method method : methods)
        {
            System.out.println(method);
        }
    }
 
}

Routine 2: Methoden durch Reflexion aufrufen Methoden durch Reflexion aufrufen. Einzelheiten finden Sie im Code und in den Kommentaren:

import java.lang.reflect.Method;
 
public class InvokeTester
{
    public int add(int param1, int param2)
    {
        return param1 + param2;
 
    }
 
    public String echo(String message)
    {
        return "Hello: " + message;
    }
 
    public static void main(String[] args) throws Exception
    {
 
        // 以前的常规执行手段
        InvokeTester tester = new InvokeTester();
        System.out.println(tester.add(1, 2));
        System.out.println(tester.echo("Tom"));
        System.out.println("---------------------------");
 
        // 通过反射的方式
 
        // 第一步，获取Class对象
        // 前面用的方法是：Class.forName()方法获取
        // 这里用第二种方法，类名.class
        Class<?> classType = InvokeTester.class;
 
        // 生成新的对象：用newInstance()方法
        Object invokeTester = classType.newInstance();
        System.out.println(invokeTester instanceof InvokeTester); // 输出true
 
        // 通过反射调用方法
        // 首先需要获得与该方法对应的Method对象
        Method addMethod = classType.getMethod("add", new Class[] { int.class,
                int.class });
        // 第一个参数是方法名，第二个参数是这个方法所需要的参数的Class对象的数组
 
        // 调用目标方法
        Object result = addMethod.invoke(invokeTester, new Object[] { 1, 2 });
        System.out.println(result); // 此时result是Integer类型
 
        //调用第二个方法
        Method echoMethod = classType.getDeclaredMethod("echo", new Class[]{String.class});
        Object result2 = echoMethod.invoke(invokeTester, new Object[]{"Tom"});
        System.out.println(result2);
 
    }
}

Objekte generieren

Wenn Sie Objekte über die Konstruktormethode einer Klasse ohne Parameter generieren möchten, haben wir zwei Möglichkeiten:

1 Zuerst das Klassenobjekt abrufen und dann übergeben Sie das Klassenobjekt Die newInstance()-Methode von Die Klasse verfügt über einen parameterlosen Konstruktor und einen parametrisierten Konstruktor):

 Class<?> classType = String.class;
 
 Object obj = classType.newInstance();

Wenn Sie ein Objekt über den parametrisierten Konstruktor der Klasse generieren möchten, können Sie nur die folgende Methode verwenden:

(Kunde ist eine benutzerdefinierte Klasse, die über einen parameterlosen Konstruktor und einen parametrisierten Konstruktor verfügt und Zeichenfolgen und Ganzzahlen übergibt)

    Class<?> classType = Customer.class;
 
    Constructor cons2 = classType.getConstructor(new Class[] {String.class, int.class});
 
    Object obj2 = cons2.newInstance(new Object[] {"ZhangSan",20});

可以看出调用构造方法生成对象的方法和调用一般方法的类似，不同的是从Class对象获取Constructor对象时不需要指定名字，而获取Method对象时需要指定名字。

相关视频教程推荐：Java视频教程

Das obige ist der detaillierte Inhalt vonWas ist Reflexion in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!