Dans ce tutoriel, 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 Classqui 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 sur les classes Java
Afin de refléter une classe Java, nous devons d'abord créer un objet de classe.
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 façons de créer des objets de classe:
1. Utilisation de la méthode forName ()
class Dog (… ) // create object of Class // to reflect the Dog class Class a = Class.forName("Dog");
Ici, la forName()méthode prend le nom de la classe à refléter comme argument.
2. Utilisation de la méthode getClass ()
// 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 de la classe Dog pour créer un objet de classe.
3. Utilisation de l'extension .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 au moment 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(); ) ) )
Production
Nom: Chien Modificateur: public Superclasse: Animal
Dans l'exemple ci-dessus, nous avons créé une superclasse: Animal et une sous-classe: Dog. Ici, nous essayons d'inspecter la classe Dog.
Notez la déclaration,
Class obj = d1.getClass();
Ici, nous créons un objet obj de Class en utilisant la 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 () - retourne le modificateur d'accès de la classe
- obj.getSuperclass () - renvoie la super classe de la classe
Pour en savoir plus Class, visitez Java Class (documentation Java officielle).
Remarque : nous utilisons la Modifierclasse pour convertir le modificateur d'accès entier en chaîne.
Refléter les champs, les méthodes et les constructeurs
Le package java.lang.reflectfournit des classes qui peuvent être utilisées pour manipuler les membres de classe. Par exemple,
- Classe de méthode - fournit des informations sur les méthodes d'une classe
- Classe de champ - fournit des informations sur les champs d'une classe
- Classe constructeur - fournit des informations sur les constructeurs dans une classe
1. Réflexion sur les méthodes Java
La Methodclasse 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(); ) ) )
Production
Nom de la méthode: display Modificateur: public Types de retour: void Nom de la méthode: makeSound Modificateur: privé Types de retour: void
Dans l'exemple ci-dessus, nous essayons d'obtenir des informations sur les méthodes présentes dans la classe Dog. Comme mentionné précédemment, nous avons d'abord créé un objet objet d' Classutilisation de la getClass()méthode.
Remarquez l'expression,
Method() methods = obj.getDeclaredMethod();
Ici, le getDeclaredMethod()retourne toutes les méthodes présentes à l'intérieur de la classe.
De plus, nous avons créé un objet m de la Methodclasse. Ici,
- m.getName () - renvoie le nom d'une méthode
- m.getModifiers () - retourne le modificateur d'accès des méthodes sous forme entière
- m.getReturnType () - renvoie le type de retour des méthodes
La Methodclasse 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 Java officielle).
2. Réflexion sur les champs Java
Comme les méthodes, nous pouvons également inspecter et modifier différents champs d'une classe en utilisant les méthodes de la Fieldclasse. 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(); ) ) )
Production
Valeur: labrador Modificateur: public
Dans l'exemple ci-dessus, nous avons créé une classe nommée Dog. Il comprend un champ public nommé type. Notez la déclaration,
Field field1 = obj.getField("type");
Here, we are accessing the public field of the Dog class and assigning it to the object field1 of the Field class.
We then used various methods of the Field class:
- field1.set() - sets the value of the field
- field1.get() - returns the value of field
- field1.getModifiers() - returns the value of the field in integer form
Similarly, we can also access and modify private fields as well. However, the reflection of private field is little bit different than the public field. For example,
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(); ) ) )
Output
Value: brown Modifier: private
In the above example, we have created a class named Dog. The class contains a private field named color. Notice the statement.
Field field1 = obj.getDeclaredField("color"); field1.setAccessible(true);
Here, we are accessing color and assigning it to the object field1 of the Field class. We then used field1 to modify the accessibility of color and allows us to make changes to it.
We then used field1 to perform various operations on the private field color.
To learn more about the different methods of Field, visit Java Field Class (official Java documentation).
3. Reflection of Java Constructor
We can also inspect different constructors of a class using various methods provided by the Constructor class. For example,
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(); ) ) )
Output
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
In the above example, we have created a class named Dog. The class includes two constructors.
We are using reflection to find the information about the constructors of the class. Notice the statement,
Constructor() constructors = obj.getDeclaredConstructor();
Ici, nous accédons à tous les constructeurs présents dans Dog et les assignons à un tableau de constructeurs de Constructortype.
Nous avons ensuite utilisé l'objet c pour obtenir différentes informations sur le constructeur.
- c.getName () - renvoie le nom du constructeur
- c.getModifiers () - retourne les modificateurs d'accès du constructeur sous forme entière
- c.getParameterCount () - renvoie le nombre de paramètres présents dans chaque constructeur
Pour en savoir plus sur plus de méthodes de la Constructorclasse, visitez la classe Constructor
