Was ist Reflektion in Java

1. Klassenobjekt
2. Klasse forName() Methode in Java
3. Klasse getClass() Methode in Java
4. Nützliche Reflexionsmethoden in Java
5. Nützliche Methoden zum Nachdenken über Methoden
6. Nützliche Methoden zur Reflexion über Felder
7. Fazit

Dieses Tutorial stellt die Reflektion und ihre Verwendung in Java vor. Java verfügt über eine Reflection-API-Funktion, mit der wir Klassen, Schnittstellen usw. untersuchen und ändern können.

In diesem Tutorial lernen wir, was die Reflection-API ist und wie sie verwendet wird. Reflection in Java ermöglicht es uns, Klassen, Schnittstellen, Konstruktoren, Methoden und Felder während der Laufzeit zu beobachten und zu ändern, selbst wenn wir den Klassennamen während der Kompilierzeit nicht kennen.

Das Erstellen neuer Objekte, das Aufrufen von Methoden und das Abrufen/Festlegen von Feldwerten kann allesamt mit Reflektion erfolgen. Lassen Sie uns anhand einiger Beispiele verstehen.

Wir müssen zuerst das folgende Paket importieren, um die Reflexions-API zu verwenden.

java.lang.reflect.*

Es importiert alle Klassen, die in der Reflexions-API enthalten sind.

Klassenobjekt

Nach dem Importieren des Pakets müssen wir ein Klassenobjekt erstellen, um die Reflection-API-Methoden zu verwenden.

Class existiert in Java, da es alle Daten über Objekte und Klassen während der Laufzeit verfolgt. Reflektion kann auf dem Class-Objekt ausgeführt werden.

Ein Klassenobjekt kann auf drei Arten erstellt werden. Wir werden uns jede Methode einzeln ansehen.

Aber vorher erstellen wir eine Klasse, die wir in diesem Tutorial verwenden werden.

class Furniture {
  public String name;
  private int price;

  public Furniture(String name, int price) {
    this.name = name;
    this.price = price;
  }

  public void update_price(int up_price) {
    this.price = up_price;
  }

  private float cal_discount(int discount) {
    float discounted_price = (1 - discount / 100) * this.price;
    return discounted_price;
  }
}

Lassen Sie uns nun ein Objekt der Klasse Class der Möbelklasse erstellen.

Klasse forName() Methode in Java

Klasse Klasse bietet eine Methode forName() zum Laden von Objekten.

Um diese Methode zu verwenden, müssen wir den Namen der Klasse kennen, über die wir reflektieren möchten. Anschließend übergeben wir den Klassennamen als Argument an die Methode forName().

Sehen Sie sich den folgenden Code an:

Class class
= Class.forName("Furniture");

Diese Methode wirft eine ClassNotFoundException, wenn Java die Klasse nicht finden kann.

Klasse getClass() Methode in Java

Wir rufen diese Methode für das Objekt der Klasse auf, über das wir reflektieren möchten. Diese Methode gibt die Klasse des Objekts zurück.

Sehen Sie sich den folgenden Code an:

Furniture furniture = new Furniture("Chair", 8565);
Class f = furniture.getClass();

Wir können auch die Funktion .class verwenden, um Klassenobjekte zur Reflektion zu erhalten.

// create a class object to relect on furniture
Class f = Furniture.class;

Nützliche Reflexionsmethoden in Java

Das Klassenobjekt hat die folgenden drei Methoden, die verwendet werden können, um über die Klasse nachzudenken.

• getName(): Diese Methode gibt den Namen der Klasse zurück.
• getModifiers(): Diese Methode gibt eine Ganzzahl zurück, die den Zugriffsmodifikator der Klasse darstellt. Diese Ganzzahl können wir dann mit der Methode Modifier.toString() in einen String umwandeln.
• getSuperclass(): Diese Methode gibt die Oberklasse der Methode zurück.

Sehen wir uns ein Beispiel an, um diese Methoden zu verstehen.

import java.lang.reflect.Modifier;
public class SimpleTesting {
  public static void main(String[] args) {
    // create an object of furniture class
    Furniture furniture = new Furniture("Chair", 8565);
    // create a class object to relect on furniture
    Class f = furniture.getClass();

    // get the name of the class
    String class_name = f.getName();
    System.out.println("The class name is " + class_name);

    // get the class modifier
    int f_modifier = f.getModifiers();
    String f_mod = Modifier.toString(f_modifier);
    System.out.println("The modifier of the class is " + f_mod);

    // get the superclass of the class
    Class f_superclass = f.getSuperclass();
    System.out.println("The Superclass of the class is " + f_superclass.getName());
  }
}

Ausgabe:

The class name is Furniture
The modifier of the class is
The Superclass of the class is java.lang.Object

Nützliche Methoden zum Nachdenken über Methoden

Java stellt eine Klasse namens Method bereit, die sich mit Methoden während der Reflektion befasst.

Eine Methode namens getDeclaredMethods() gibt ein Array aller in der Klasse definierten Methoden zurück. Die zurückgegebenen Methoden gehören zur Klasse Method.

Die Method-Klasse enthält mehrere Methoden zum Abrufen von Informationen über die Methoden in einer Klasse. Wir werden die folgenden Methoden der Methodenklasse verwenden:

• Method.getName(): Diese Methode gibt den Namen der Methode zurück.
• Method.getModifiers(): Diese Methode gibt eine Ganzzahl zurück, die den Zugriffsmodifikator der Methode darstellt.
• Method.getReturnType(): Diese Methode gibt den Rückgabetyp der Methode zurück.

Sehen wir uns ein Beispiel an, um diese Methoden zu verstehen.

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class SimpleTesting {
  public static void main(String[] args) {
    // create an object of furniture class
    Furniture furniture = new Furniture("Chair", 8565);
    // create a class object to relect on furniture
    Class f = furniture.getClass();

    // using object f of Class to
    // get all the declared methods of Furniture
    Method[] f_methods = f.getDeclaredMethods();

    for (Method f_method : f_methods) {
      // get the name of the method
      System.out.println("Method Name: " + f_method.getName());

      // get the access modifier of methods
      int f_modifier = f_method.getModifiers();
      System.out.println("Modifier: " + Modifier.toString(f_modifier));

      // get the return type of the methods
      System.out.println("Return Types: " + f_method.getReturnType());
      System.out.println(" ");
    }
  }
}

Ausgabe:

Method Name: update_price
Modifier: public
Return Types: void

Method Name: cal_discount
Modifier: private
Return Types: float

Im obigen Beispiel versuchen wir, etwas über die Methoden zu erfahren, die in der Möbelklasse definiert sind. Wir müssen zuerst ein Klassenobjekt mit der Methode getClass() erstellen.

Nützliche Methoden zur Reflexion über Felder

Wir können auch verschiedene Felder einer Klasse mit den Methoden der Field-Klasse untersuchen und ändern. Es gibt eine Methode namens.

class.getField
(<field name>)

Diese Methode nimmt ein Argument entgegen: den Namen des Felds, auf das wir zugreifen möchten, und gibt ein Field-Objekt des übergebenen Felds zurück. Wir können dann das Field-Klassenobjekt verwenden, um verschiedene Methoden aufzurufen.

Wir werden die folgenden Methoden der Field-Klasse verwenden.

• Field.set(): Diese Methode setzt den Wert des Feldes.
• Field.get(): Diese Methode gibt den im Feld gespeicherten Wert zurück.
• Field.getModifier(): Diese Methode gibt eine Ganzzahl zurück, die den Zugriffsmodifikator des Felds darstellt.

Sehen wir uns ein Beispiel an, um diese Methoden zu verstehen.

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class SimpleTesting {
  public static void main(String[] args) throws Exception {
    // create object of the furniture class
    Furniture furniture = new Furniture("Chair", 8565);
    // create a class object to relect on furniture
    Class f = furniture.getClass();

    // using object f of Class to
    // acces the name field of Furniture
    Field f_name = f.getField("name");

    // get the value of the field
    String f_name_value = (String) f_name.get(furniture);
    System.out.println("Field value before changing: " + f_name_value);

    // changing the field value
    f_name.set(furniture, "Table");

    // get the value of the field
    f_name_value = (String) f_name.get(furniture);
    System.out.println("Field value after changing: " + f_name_value);

    // get the access modifier
    int f_name_mod = f_name.getModifiers();

    // convert the access modifier to String form
    String f_name_modifier = Modifier.toString(f_name_mod);
    System.out.println("Modifier: " + f_name_modifier);
    System.out.println(" ");
  }
}

Ausgabe:

Field value before changing: Chair
Field value after changing: Table
Modifier: public

Der Zugriff auf ein privates Feld ist ähnlich, außer dass wir die Zugänglichkeit des privaten Felds ändern müssen, indem wir die Methode setAccessible() verwenden und true als Argument übergeben.

Sehen Sie sich den Beispielcode unten an; Wir versuchen, auf den privaten Feldpreis der Möbelklasse zuzugreifen und ihn zu ändern.

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class SimpleTesting {
  public static void main(String[] args) throws Exception {
    // create object of the furniture class
    Furniture furniture = new Furniture("Chair", 8565);
    // create a class object to reflect on furniture
    Class f = furniture.getClass();

    // using object f of Class to
    // access the price field of Furniture
    Field f_price = f.getDeclaredField("price");

    // modifying the accessibility
    f_price.setAccessible(true);

    // get the value of the field
    int f_price_value = (Integer) f_price.get(furniture);
    System.out.println("Field value before changing: " + f_price_value);

    // changing the field value
    f_price.set(furniture, 453);

    // get the value of the field
    f_price_value = (Integer) f_price.get(furniture);
    System.out.println("Field value after changing: " + f_price_value);

    // get the access modifier
    int f_price_mod = f_price.getModifiers();

    // convert the access modifier to String form
    String f_price_modifier = Modifier.toString(f_price_mod);
    System.out.println("Modifier: " + f_price_modifier);
    System.out.println(" ");
  }
}

Ausgabe:

Field value before changing: 8565
Field value after changing: 453
Modifier: private

Fazit

Nachdem wir diesen Artikel gelesen haben, haben wir ein ausreichendes Verständnis der Reflektion in Java.

Wir haben auch die Klassen und Methoden in Java untersucht, die zur Reflexion verwendet werden. Wir haben gelernt, wie man den Namen der Klasse und ihrer Methoden und Felder erhält.

Mit der Reflection-API können wir schnell Informationen über die Klasse erhalten.