Qu'est-ce que la réflexion en Java
- 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.
javaCopyjava.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.
javaCopyclass 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 :
javaCopyClass 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 :
javaCopyFurniture 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.
javaCopy// 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éthodeModifier.toString()
.getSuperclass()
: Cette méthode renvoie la Superclasse de la méthode.
Voyons un exemple pour comprendre ces méthodes.
javaCopyimport 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 :
textCopyThe 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.
javaCopyimport 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 :
textCopyMethod 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.
javaCopyclass.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.
javaCopyimport 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 :
textCopyField 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.
javaCopyimport 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 :
textCopyField 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.