Java Reflection (Reflection)

Dans ce tutoriel, nous allons étudier la réflexion, qui est une caractéristique de la programmation Java nous permettant de vérifier et de modifier les classes, les méthodes, etc.

En Java, la réflexion nous permet de vérifier et de manipuler les classes, les interfaces, les constructeurs, les méthodes et les champs au moment de l'exécution.

Le nom de la classe Java est Class

Avant d'étudier la réflexion en Java, nous devons comprendre une classe Java nommée Class.

Dans Java, il existe une classe nommée Class qui conserve toutes les informations sur les objets et les classes au moment de l'exécution.

L'objet Class décrit les attributs spécifiques d'une classe. Cet objet est utilisé pour effectuer la réflexion.

Créer un objet de la classe nommée Class

Nous pouvons créer des objets Class en :

• Utiliser la méthode forName()

La méthode forName() accepte un paramètre de chaîne (le nom de la classe) et retourne un objet Class. L'objet retourné fait référence à la classe spécifiée par la chaîne. Par exemple,

Class Dog { }
Class c1　= Class.forName("Dog");

• Utiliser la méthode getClass()

　La méthode getClass() utilise un objet spécifique de la classe pour créer un nouveau objet Class. Par exemple,

Dog d1　= new Dog()
Class c1　= d1.getClass();

• Utiliser .class

Nous pouvons également utiliser.classCréer un objet Class en utilisant l'extension. Par exemple,

Class c1　= Dog.class;

Après avoir créé un objet Class, nous pouvons utiliser ces objets pour effectuer la réflexion.

Obtenir l'interface

Nous pouvons utiliser la méthode getInterfaces() de Class pour collecter des informations sur les interfaces implémentées par la classe. Cette méthode retourne un tableau d'interfaces.

Exemple : obtenir l'interface

import java.lang.Class;
import java.lang.reflect.*;
interface Animal {
　　　public void display();
}
interface Mammal {
　　　public void makeSound();
}
class Dog implements Animal, Mammal {
　　　public void display() {
　　　　　　System.out.println("Je suis un chien.");
　　　}
　　　public void makeSound() {
　　　　　　System.out.println("Bark bark");
　　　}
}
class ReflectionDemo {
　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　//Créer un objet de la classe Dog
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Créer un objet Class en utilisant getClass()
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　
　　　　　　　　　　//Recherche des interfaces implémentées par Dog
　　　　　　　　　　Class[] objInterface = obj.getInterfaces();
　　　　　　　　　　for(Class c : objInterface) {
　　　　　　　　　　　　　　//Afficher le nom de l'interface
　　　　　　　　　　　　　　System.out.println("Nom de l'interface: ")　+　c.getName());
　　　　　　　　　　}
　　　　　　}
　　　　　　catch(Exception e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　}
　　　}
}

Output result

Nom de l'interface : Animal
Nom de l'interface : Mammal

Obtenir la superclasse et le modificateur d'accès

La méthode getSuperclass() de la classe Class peut être utilisée pour obtenir des informations sur la superclasse d'une classe spécifique.

De plus, la méthode getModifier() de Class fournit un modificateur de la classe sous forme d'entier.

Exemple : obtenir la superclasse et le modificateur d'accès

import java.lang.Class;
import java.lang.reflect.*;
interface Animal {
　　　public void display();
}
public class Dog implements Animal {
　　　public void display() {
　　　　　　　System.out.println("Je suis un chien.");
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　　try {
　　　　　　　　　　　//Créer un objet de la classe Dog
　　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　　//Créer un objet Class en utilisant getClass()
　　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　　//Obtenir le modificateur d'accès de Dog sous forme d'entier
　　　　　　　　　　　int modifier = obj.getModifiers();
　　　　　　　　　　　System.out.println("Modifier: ",　+　Modifier.toString(modifier));
　　　　　　　　　　　//Trouver la superclasse de Dog
　　　　　　　　　　　Class superClass = obj.getSuperclass();
　　　　　　　　　　　System.out.println("Superclasse : ")　+　superClass.getName());
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Output result

Modifier: public
Superclasse : Animal

Reflection champ, méthode et constructeur

Le paquet java.lang.reflect fournit des classes utilisables pour manipuler les membres de la classe. Par exemple,

• Classe Méthode - Fournir des informations sur les méthodes de la classe

• Classe Champ - Fournir des informations sur les champs de la classe

• Classe Constructeur　 - Fournir des informations sur les constructeurs de la classe

Reflection Java et champs

　Nous pouvons utiliser diverses méthodes fournies par la classe Field pour vérifier et modifier différents champs de la classe.

• getFields() - Retourner tous les champs publics de la classe et de ses classes parentes

• getDeclaredFields()　 - Retourner tous les champs de la classe

• getModifier() - Retourner les modificateurs du champ sous forme d'entier

• set(classObject,value) - Définir la valeur du champ avec la valeur spécifiée

• get(classObject) - Obtenir la valeur du champ

• setAccessible(boolean) - Rendre le champ privé accessible

Remarque :Si nous connaissons le nom du champ, nous pouvons utiliser

• getField("fieldName") - Retourner le nom du champ de la classefieldNamedu champ public.

• getDeclaredField("fieldName") - Retourner le nom du champ de la classefieldNamedu champ.
  

Exemple : accéder aux champs publics

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　public String type;
}
class ReflectionDemo {
　　public static void main(String[] args) {
　　　　　try{
　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Créer un objet Class
　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　//Manipuler le champ public type de la classe Dog
　　　　　　　　　Field field1　= obj.getField("type");
　　　　　　　　//Définir la valeur du champ
　　　　　　　　　field1.set(d1, "labrador");
　　　　　　　　//Obtenir la valeur du champ en le convertissant en chaîne
　　　　　　　　　String typeValue = (String)field1.get(d1);
　　　　　　　　　System.out.println("type : ");　+　typeValue);
　　　　　　　　　//Obtenir le modificateur d'accès du type
　　　　　　　　　int mod1　= field1.getModifiers();
　　　　　　　　　String modifier1　= Modifier.toString(mod1);
　　　　　　　　　System.out.println("Modifier: ",　+　modificateur1);
　　　　　　　　　System.out.println(" ");
　　　　　}
　　　　　catch(Exception e) {
　　　　　　　　　e.printStackTrace();
　　　　　}
　　}
}

Output result

type : labrador
Modifier: public

Exemple : accès au champ privé

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　private String color;
}
class ReflectionDemo {
public static void main(String[] args) {
　　　try {
　　　　　　Dog d1　= new Dog();
　　　　　　//Créer un objet de classe Class
　　　　　　Class obj = d1.getClass();
　　　　　　//Accéder au champ privé
　　　　　　Field field2　= obj.getDeclaredField("color");
　　　　　
　　　　　　//Rendre le champ privé accessible
　　　　　　field2.setAccessible(true);
　　　　　　//Définir la valeur de color
　　　　　　field2.set(d1, "brun");
　　　　　　//　Obtenir la valeur du type en le convertissant en chaîne
　　　　　　String colorValue = (String)field2.get(d1);
　　　　　　System.out.println("couleur : ");　+　colorValue);
　　　　　　//Obtenir le modificateur d'accès de 'color'
　　　　　　int mod2　= field2.getModifiers();
　　　　　　String modifier2　= Modifier.toString(mod2);
　　　　　　System.out.println("modificateur : ");　+　modificateur2);
　　　}
　　　catch(Exception e) {
　　　　　　e.printStackTrace();
　　　}
　}
}

Output result

couleur : brun
modificateur : private

Java Reflection et Méthodes

Comme pour les champs, nous pouvons utiliser diverses méthodes fournies par la classe Method pour vérifier différentes méthodes de la classe.

• getMethods() - Renvoie toutes les méthodes publiques de la classe et de ses classes parentes

• getDeclaredMethod() - Renvoie toutes les méthodes de la classe

• getName() - Renvoie le nom de la méthode

• getModifiers() - Renvoie le modificateur d'accès de la méthode sous forme d'entier

• getReturnType() - Renvoie le type de retour de la méthode

Exemple : réflexion sur les méthodes

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　　public void display() {
　　　　　　System.out.println("Je suis un chien.");
　　　}
　　　protected void eat() {
　　　　　　System.out.println("Je mange de la nourriture pour chiens.");
　　　}
　　　private void makeSound() {
　　　　　　System.out.println("Bark Bark");
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Créer un objet Class
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　
　　　　　　　　　　//Obtenir toutes les méthodes en utilisant getDeclaredMethod()
　　　　　　　　　　Method[] methods = obj.getDeclaredMethods();
　　　　　　　　　　//Obtenir le nom de la méthode
　　　　　　　　　　for(Method m : methods) {
　　　　　　　　　　　　　　　
　　　　　　　　　　　　　System.out.println("Nom de la méthode : ");　+　m.getName());
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Obtenir l'accessibilité de la méthode
　　　　　　　　　　　　　int modifier = m.getModifiers();
　　　　　　　　　　　　　System.out.println("Modifier: ",　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Obtenir le type de retour de la méthode
　　　　　　　　　　　　　System.out.println("Return Types: ");　+　m.getReturnType());
　　　　　　　　　　　　　System.out.println(" ");
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Output result

Nom de la méthode : display
Modifier: public
Return type: void
Nom de la méthode : eat
Modificateur : protected
Retourne le type : void
Nom de la méthode : makeSound
Modifier: private
Retourne le type : void

Java reflection et constructeurs

Nous pouvons également utiliser diverses méthodes fournies par la classe Constructor pour vérifier différents constructeurs de la classe.

• getConstructors() - Retourne tous les constructeurs publics de la classe et de ses classes parentes

• getDeclaredConstructor() -Retourne tous les constructeurs

• getName() - Retourne le nom du constructeur

• getModifiers() - Retourne l'accessibilité du constructeur sous forme d'entier

• getParameterCount() - Retourne le nombre de paramètres du constructeur

Exemple : réflexion sur les constructeurs

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　　public Dog() {
　　　　　　
　　　}
　　　public Dog(int age) {
　　　　　　
　　　}
　　　private Dog(String sound, String type) {
　　　　　　
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　　//Obtenir tous les constructeurs d'une classe en utilisant getDeclaredConstructor()
　　　　　　　　　　　Constructor[] constructors = obj.getDeclaredConstructors();
　　　　　　　　　　　for(Constructor c : constructors) {
　　　　　　　　　　　　　　　//Get the name of the constructor
　　　　　　　　　　　　　　　System.out.println("Constructor name: ",　+　c.getName());
　　　　　　　　　　　　　　　//Get the access modifier of the constructor
　　　　　　　　　　　　　　　int modifier = c.getModifiers();
　　　　　　　　　　　　　　　System.out.println("Modifier: ",　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　　//Get the number of parameters in the constructor
　　　　　　　　　　　　　　　System.out.println("Number of parameters: ",　+　c.getParameterCount());
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　　}
}

Output result

Constructor name: Dog
Modifier: public
Number of parameters: 0
Constructor name: Dog
Modifier: public
Number of parameters:　1
Constructor name: Dog
Modifier: private
Number of parameters:　2