Qu'est-ce que la réflexion en Java

Mohammad Irfan 12 octobre 2023

Java Java Reflection

Objet de classe
Classe forName() Méthode en Java
Méthode de classe getClass() en Java
Méthodes utiles pour la réflexion en Java
Méthodes utiles pour la réflexion sur les méthodes
Méthodes utiles pour la réflexion sur les champs
Conclusion

Ce tutoriel présente la réflexion et comment l’utiliser en Java. Java a une fonctionnalité d’API de réflexion qui nous permet d’inspecter et de modifier les classes, les interfaces, etc.

Dans ce tutoriel, nous apprenons ce qu’est l’API de réflexion et ses utilisations. La réflexion en Java nous permet d’observer et de modifier les classes, les interfaces, les constructeurs, les méthodes et les champs pendant l’exécution, même si nous ne connaissons pas le nom de la classe pendant la compilation.

La création de nouveaux objets, l’invocation de méthodes et l’obtention/la définition de valeurs de champ peuvent toutes être effectuées avec réflexion. Comprenons avec quelques exemples.

Nous devons d’abord importer le package suivant pour utiliser l’API de réflexion.

java.lang.reflect.*

Il importe toutes les classes contenues dans l’API de réflexion.

Objet de classe

Après avoir importé le package, nous devons créer un objet de classe pour utiliser les méthodes de l’API de réflexion.

La classe existe en Java car elle garde une trace de toutes les données sur les objets et les classes pendant l’exécution. La réflexion peut être exécutée sur l’objet Class.

Un objet de classe peut être créé de trois manières. Nous examinerons chaque méthode une par une.

Mais avant cela, créons une classe que nous utiliserons tout au long de ce tutoriel.

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;
  }
}

Maintenant, créons un objet de classe Class de la classe de meubles.

Classe `forName()` Méthode en Java

La classe class fournit une méthode forName() pour charger l’objet.

Pour utiliser cette méthode, nous devons connaître le nom de la classe sur laquelle nous voulons réfléchir. Nous passons ensuite le nom de la classe comme argument à la méthode forName().

Regardez le code ci-dessous :

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

Cette méthode lève une ClassNotFoundException si Java ne trouve pas la classe.

Méthode de classe `getClass()` en Java

On appelle cette méthode sur l’objet de la classe sur laquelle on veut réfléchir. Cette méthode renvoie la classe de l’objet.

Regardez le code ci-dessous :

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

Nous pouvons également utiliser la fonctionnalité .class pour obtenir des objets de classe pour la réflexion.

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

Méthodes utiles pour la réflexion en Java

L’objet de classe a les trois méthodes suivantes, qui peuvent être utilisées pour réfléchir sur la classe.

getName() : Cette méthode renvoie le nom de la classe.
getModifiers() : Cette méthode renvoie un entier représentant le modificateur d’accès de la classe. Nous pouvons ensuite convertir cet entier en String en utilisant la méthode Modifier.toString().
getSuperclass() : Cette méthode renvoie la Superclasse de la méthode.

Voyons un exemple pour comprendre ces méthodes.

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());
  }
}

Production :

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

Méthodes utiles pour la réflexion sur les méthodes

Java fournit une classe appelée Method qui traite des méthodes lors de la réflexion.

Une méthode appelée getDeclaredMethods() renvoie un tableau de toutes les méthodes définies dans la classe. Les méthodes retournées appartiennent à la classe Method.

La classe Method contient plusieurs méthodes pour récupérer des informations sur les méthodes d’une classe. Nous allons utiliser les méthodes suivantes de la classe method :

Method.getName() : Cette méthode renvoie le nom de la méthode.
Method.getModifiers() : Cette méthode renvoie un entier représentant le modificateur d’accès de la méthode.
Method.getReturnType() : Cette méthode renvoie le type de retour de la méthode.

Voyons un exemple pour comprendre ces méthodes.

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(" ");
    }
  }
}

Production :

Method Name: update_price
Modifier: public
Return Types: void

Method Name: cal_discount
Modifier: private
Return Types: float

Dans l’exemple ci-dessus, nous essayons de connaître les méthodes définies dans la classe Furniture. Nous devons d’abord créer un objet Class en utilisant la méthode getClass().

Méthodes utiles pour la réflexion sur les champs

Nous pouvons également inspecter et modifier différents champs d’une classe en utilisant les méthodes de la classe Field. Il existe une méthode appelée.

class.getField
(<field name>)

Cette méthode prend un argument : le nom du champ auquel nous voulons accéder et renvoie un objet Field du champ passé. Nous pouvons ensuite utiliser l’objet de classe Field pour appeler diverses méthodes.

Nous allons utiliser les méthodes suivantes de la classe Field.

Field.set() : cette méthode définit la valeur du champ.
Field.get() : Cette méthode renvoie la valeur stockée dans le champ.
Field.getModifier() : Cette méthode renvoie un entier représentant le modificateur d’accès du champ.

Voyons un exemple pour comprendre ces méthodes.

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(" ");
  }
}

Production :

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

Accéder à un champ privé est similaire sauf qu’il faut modifier l’accessibilité du champ privé en utilisant la méthode setAccessible() et en passant true en argument.

Regardez l’exemple de code ci-dessous ; nous essayons d’accéder et de modifier le prix du champ privé de la classe Meubles.

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(" ");
  }
}

Production :

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

Conclusion

Nous avons une compréhension suffisante de la réflexion en Java après avoir lu cet article.

Nous avons également étudié les classes et les méthodes en Java utilisées pour la réflexion. Nous avons appris comment obtenir le nom de la classe et ses méthodes et champs.

En utilisant l’API de réflexion, nous pouvons obtenir rapidement des informations sur la classe.

Objet de classe

Classe forName() Méthode en Java

Méthode de classe getClass() en Java

Méthodes utiles pour la réflexion en Java

Méthodes utiles pour la réflexion sur les méthodes

Méthodes utiles pour la réflexion sur les champs

Conclusion

Classe `forName()` Méthode en Java

Méthode de classe `getClass()` en Java