Réflexion Java
Réflexion Java
Dans ce didacticiel, nous allons apprendre la réflexion, une fonctionnalité de la programmation Java qui nous permet d'inspecter et de modifier des classes, des méthodes, etc.
En Java, la réflexion nous permet d'inspecter et de manipuler des classes, des interfaces, des constructeurs, des méthodes et des champs au moment de l'exécution.
Il existe une classe en Java nommée Class qui conserve toutes les informations sur les objets et les classes au moment de l'exécution. L'objet de Classe peut être utilisé pour effectuer une réflexion.
Réflexion des classes Java
Afin de refléter une classe Java, nous devons d'abord créer un objet de Class .
Et, en utilisant l'objet, nous pouvons appeler diverses méthodes pour obtenir des informations sur les méthodes, les champs et les constructeurs présents dans une classe.
Il existe trois manières de créer des objets de Class :
class Dog {...}
// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");
Ici, le forName() prend le nom de la classe à refléter comme argument.
// create an object of Dog class
Dog d1 = new Dog();
// create an object of Class
// to reflect Dog
Class b = d1.getClass(); Ici, nous utilisons l'objet du Chien class pour créer un objet de Class .
// create an object of Class
// to reflect the Dog class
Class c = Dog.class;
Maintenant que nous savons comment créer des objets du Class . Nous pouvons utiliser cet objet pour obtenir des informations sur la classe correspondante lors de l'exécution.
Exemple :réflexion de classe Java
import java.lang.Class;
import java.lang.reflect.*;
class Animal {
}
// put this class in different Dog.java file
public class Dog extends Animal {
public void display() {
System.out.println("I am a dog.");
}
}
// put this in Main.java file
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// get name of the class
String name = obj.getName();
System.out.println("Name: " + name);
// get the access modifier of the class
int modifier = obj.getModifiers();
// convert the access modifier to string
String mod = Modifier.toString(modifier);
System.out.println("Modifier: " + mod);
// get the superclass of Dog
Class superClass = obj.getSuperclass();
System.out.println("Superclass: " + superClass.getName());
}
catch (Exception e) {
e.printStackTrace();
}
}
} Sortie
Name: Dog Modifier: public Superclass: Animal
Dans l'exemple ci-dessus, nous avons créé une superclasse :Animal et une sous-classe :Chien . Ici, nous essayons d'inspecter la classe Chien .
Remarquez la déclaration,
Class obj = d1.getClass();
Ici, nous créons un objet obj de classe en utilisant le getClass() méthode. En utilisant l'objet, nous appelons différentes méthodes de Class .
- obj.getName() - renvoie le nom de la classe
- obj.getModifiers() - renvoie le modificateur d'accès de la classe
- obj.getSuperclass() - renvoie la super classe de la classe
Pour en savoir plus sur Class , visitez Java Class (documentation officielle de Java).
Remarque :Nous utilisons le Modifier class pour convertir le modificateur d'accès entier en chaîne.
Champs, méthodes et constructeurs reflétant
Le paquet java.lang.reflect fournit des classes qui peuvent être utilisées pour manipuler des membres de classe. Par exemple,
- Classe de méthode - fournit des informations sur les méthodes d'une classe
- Classe de terrain - fournit des informations sur les champs d'une classe
- Classe Constructeur - fournit des informations sur les constructeurs d'une classe
1. Reflet des méthodes Java
Le Method La classe fournit diverses méthodes qui peuvent être utilisées pour obtenir des informations sur les méthodes présentes dans une classe. Par exemple,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
// methods of the class
public void display() {
System.out.println("I am a dog.");
}
private void makeSound() {
System.out.println("Bark Bark");
}
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// using object of Class to
// get all the declared methods of Dog
Method[] methods = obj.getDeclaredMethods();
// create an object of the Method class
for (Method m : methods) {
// get names of methods
System.out.println("Method Name: " + m.getName());
// get the access modifier of methods
int modifier = m.getModifiers();
System.out.println("Modifier: " + Modifier.toString(modifier));
// get the return types of method
System.out.println("Return Types: " + m.getReturnType());
System.out.println(" ");
}
}
catch (Exception e) {
e.printStackTrace();
}
}
} Sortie
Method Name: display Modifier: public Return Types: void Method Name: makeSound Modifier: private Return Types: void
Dans l'exemple ci-dessus, nous essayons d'obtenir des informations sur les méthodes présentes dans le Dog classer. Comme mentionné précédemment, nous avons d'abord créé un objet obj de Class en utilisant le getClass() méthode.
Remarquez l'expression,
Method[] methods = obj.getDeclaredMethod();
Ici, le getDeclaredMethod() renvoie toutes les méthodes présentes dans la classe.
De plus, nous avons créé un objet m du Method classer. Ici,
- m.getName() - renvoie le nom d'une méthode
- m.getModifiers() - renvoie le modificateur d'accès des méthodes sous forme entière
- m.getReturnType() - renvoie le type de retour des méthodes
Le Method La classe fournit également diverses autres méthodes qui peuvent être utilisées pour inspecter les méthodes au moment de l'exécution. Pour en savoir plus, visitez la classe Java Method (documentation officielle de Java).
2. Réflexion des champs Java
Comme les méthodes, nous pouvons également inspecter et modifier différents champs d'une classe en utilisant les méthodes du Field classer. Par exemple,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
public String type;
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// access and set the type field
Field field1 = obj.getField("type");
field1.set(d1, "labrador");
// get the value of the field type
String typeValue = (String) field1.get(d1);
System.out.println("Value: " + typeValue);
// get the access modifier of the field type
int mod = field1.getModifiers();
// convert the modifier to String form
String modifier1 = Modifier.toString(mod);
System.out.println("Modifier: " + modifier1);
System.out.println(" ");
}
catch (Exception e) {
e.printStackTrace();
}
}
} Sortie
Value: labrador Modifier: public
Dans l'exemple ci-dessus, nous avons créé une classe nommée Chien . Il inclut un champ public nommé type . Remarquez la déclaration,
Field field1 = obj.getField("type"); Ici, nous accédons au champ public du Chien class et en l'affectant à l'objet field1 du Champ classe.
Nous avons ensuite utilisé différentes méthodes du Field classe :
- champ1.set() - définit la valeur du champ
- champ1.get() - renvoie la valeur du champ
- champ1.getModifiers() - renvoie la valeur du champ sous forme entière
De même, nous pouvons également accéder et modifier des champs privés. Cependant, le reflet du domaine privé est un peu différent de celui du domaine public. Par exemple,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
private String color;
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// access the private field color
Field field1 = obj.getDeclaredField("color");
// allow modification of the private field
field1.setAccessible(true);
// set the value of color
field1.set(d1, "brown");
// get the value of field color
String colorValue = (String) field1.get(d1);
System.out.println("Value: " + colorValue);
// get the access modifier of color
int mod2 = field1.getModifiers();
// convert the access modifier to string
String modifier2 = Modifier.toString(mod2);
System.out.println("Modifier: " + modifier2);
}
catch (Exception e) {
e.printStackTrace();
}
}
} Sortie
Value: brown Modifier: private
Dans l'exemple ci-dessus, nous avons créé une classe nommée Chien . La classe contient un champ privé nommé color . Remarquez la déclaration.
Field field1 = obj.getDeclaredField("color");
field1.setAccessible(true);
Ici, nous accédons à couleur et en l'affectant à l'objet field1 des Field classer. Nous avons ensuite utilisé field1 pour modifier l'accessibilité de couleur et nous permet d'y apporter des modifications.
Nous avons ensuite utilisé field1 pour effectuer diverses opérations sur la couleur du champ privé.
Pour en savoir plus sur les différentes méthodes de Champ , visitez Java Field Class (documentation officielle de Java).
3. Reflet du constructeur Java
Nous pouvons également inspecter différents constructeurs d'une classe en utilisant diverses méthodes fournies par le Constructor classer. Par exemple,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
// public constructor without parameter
public Dog() {
}
// private constructor with a single parameter
private Dog(int age) {
}
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// get all constructors of Dog
Constructor[] constructors = obj.getDeclaredConstructors();
for (Constructor c : constructors) {
// get the name of constructors
System.out.println("Constructor Name: " + c.getName());
// get the access modifier of constructors
// convert it into string form
int modifier = c.getModifiers();
String mod = Modifier.toString(modifier);
System.out.println("Modifier: " + mod);
// get the number of parameters in constructors
System.out.println("Parameters: " + c.getParameterCount());
System.out.println("");
}
}
catch (Exception e) {
e.printStackTrace();
}
}
} Sortie
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
Dans l'exemple ci-dessus, nous avons créé une classe nommée Chien . La classe comprend deux constructeurs.
Nous utilisons la réflexion pour trouver les informations sur les constructeurs de la classe. Remarquez la déclaration,
Constructor[] constructors = obj.getDeclaredConstructor();
Ici, nous accédons à tous les constructeurs présents dans Dog et en les affectant à un tableau constructeurs du Constructor saisir.
Nous avons ensuite utilisé l'objet c pour obtenir différentes informations sur le constructeur.
- c.getName() - renvoie le nom du constructeur
- c.getModifiers() - renvoie les modificateurs d'accès du constructeur sous forme d'entier
- c.getParameterCount() - renvoie le nombre de paramètres présents dans chaque constructeur
Pour en savoir plus sur les méthodes du Constructor classe, visitez Classe Constructeur
Java