La réflexion - programmer en java, programme java, cours

Résultat
init:
deps-jar:
Compiling 1 source file to C:\netbeans-
5.0\travail\Test\build\classes
compile:
run:
test.Personne
BUILD SUCCESSFUL (total time: 3 seconds)
Résultat
init:
deps-jar:
Compiling 1 source file to C:\netbeans-
5.0\travail\Test\build\classes
compile:
run:
test.Personne
BUILD SUCCESSFUL (total time: 3 seconds)
La réflexion
Chapitres traités La classe Class
Dans cette étude, nous allons nous pencher sur l'API de réflexion de Java, gérée par les classes du paquetage java.lang.reflect. Comme
son nom l'indique, la reflexion est la possibilité, pour une classe ou un objet, de s'examiner. Elle permet au code Java d'étudier un objet
(plus précisément la classe de l'objet) et de déterminer sa structure. Dans les limites imposées par le gestionnaire de sécurité, nous
pouvons trouver les constructeurs, les méthodes, et les attributs d'une classe ainsi que leurs valeurs.
Nous pouvons même changer la valeur des attributs, invoquer dynamiquement des méthodes, et construire de nouveaux objets, comme
si Java possédait des pointeurs sur les attributs et les méthodes.
Nous pouvons réaliser tout cela sur des objets que notre code n'a pas encore vu.
.
La bibliothèque de reflexion constitue une boîte à outils riche et élaborée pour écrire des programmes qui manipules dynamiquement du code Java. Cette
fonctionnalité est très largement utilisée dans JavaBeans, l'architecture des composants Java. Au moyen de la reflexion, Java est capable de supporter des outils
comme ceux auxquels les utilisateurs de Visual Basic sont habitués. Précisément, lorsque de nouvelles classes sont ajoutées au moment de la conception ou de
l'exécution, des outils de développement d'application rapide peuvent se renseigner dynamiquement sur les capacités des classes qui ont été ajoutées.
Une programme qui peut analyser les capacités des classes est appelé réflecteur.
.
Détermination de la classe d'un objet au moyen de la classe Class
Avant de déterminer les éléments de la classe, comme les attributs, les méthodes et les constructeurs, il faut préalablement connaître le nom même de la classe d'un objet.
Dans ce chapitre, nous allons voir comment récupérer cette information.
Lorsque le programme est lancé, le système d'exécution de Java gère, pour tous les objets, ce que l'on appelle "L'identification de type à l'exécution". Cette
information mémorise la classe à laquelle chaque objet appartient. L'information de type au moment de l'exécution est employée par la machine virtuelle pour
sélectionner les méthodes correctes à exécuter.
Obtenir une classe au moyen de la méthode getClass()
Vous pouvez accéder à cette information en travaillant avec une classe Java particulière, baptisée singulièrement Class. La méthode getClass() de la classe Object
renvoie une instance de type Class :
Tout comme un objet Personne décrit les propriétés d'une personne particulier, un objet Class décrit les propriétés d'une classe particulière. La méthode la plus
utilisée de Class est sans contexte getName(), qui renvoie le nom de la classe :
package test;
public class Main {
public static void main(String[] args) {
Personne p = new Personne("REMY", "Emmanuel");
Class cl = p.getClass();
System.out.println(cl.getName());
}
}
class Personne {
private String nom, prénom;
public Personne(String nom, String prénom) {
this.nom = nom;
this.prénom = prénom;
}
}
Obtenir une classe au moyen de la méthode forName()
Vous pouvez aussi obtenir un objet Class correspondant à une chaîne de caractères, à l'aide de la méthode statique forName() :
package test;
public class Main {
public static void main(String[] args) throws ClassNotFoundException {
String nomClasse = "test.Personne";
Class cl = Class.forName(nomClasse);
System.out.println(cl.getName());
}
}
class Personne {
private String nom, prénom;
public Personne(String nom, String prénom) {
this.nom = nom;
this.prénom = prénom;

La classe Class
Field[] getFields()
Obtient tous les attributs publics, y
compris ceux hérités. Cette méthode
renvoie un tableau contenant les objets
Field représentant les attributs publics
de cette classe ou de ses superclasses.
Cette méthode renvoie un tableau de
longueur 0s'il n'existe pas d'attribut
correspondant ou si l'objet Class
représente un type primitif ou un type
tableau.
Field getField(String nom)
Obtient l'attribut public indiqué, qui peut
être hérité.
Field[] getDeclaredFields()
Obtient tous les attributs publics ou non
publics déclarée dans cette classe (non
compris ceux hérités des classes mères).
Cette méthode renvoie un tableau
d'objets Field pour tous les attributs de
cette classe. Elle renvoie un tableau de
longueur 0s'il n'existe pas d'attribut
correspondant ou si l'objet Class
représente un type primitif ou un type
tableau.
Field getDeclaredField(String nom)
Obtient l'attribut indiqué, public ou non
public, déclaré dans cette classe (les
attributs ne sont pas pris en compte).
Method[] getMethods()
Obtient toutes les méthodes publiques, y
compris celles héritées. Cette méthode
renvoie un tableau qui contient des
objets Method. Elle renvoie des
méthodes publiques et inclut les
méthodes héritées.
Method getMethod(String nom,Class...
types)
Obtient la méthode publique indiquée
dont les arguments correspondent aux
types indiqués dans types. La méthode
peut être héritée.
Method[] getDeclaredMethods()
Obtient toutes les méthodes publiques et
non publiques de la classe (non
comprises celles héritées des classes
mères). Cette méthode renvoie un
tableau qui contient des objets Method.
Elle renvoie toutes les méthodes de cette
classe ou interface mais n'inclut pas les
méthodes héritées.
Method getDeclaredMethod(String nom,
Class... types)
Obtient la méthode indiquée, publique
ou non publique, dont les arguments
correspondent aux types indiqués dans
types, et qui est déclarée dans cette
classe (Les méthodes héritées ne sont
pas pris en compte).
Constructor[] getConstructors()
Obtient tous les constructeurs publics de
cette classe. Cette méthode renvoie un
tableau d'objets Constructor
représentant tous les constructeurs
publics.
Constructor getConstructor(Class... types)
Obtient le constructeur public indiqué de
cette classe, dont les arguments
correspondent aux types indiqués dans
types.
Constructor[] getDeclaredConstructors()
}
}
Cette technique est utilisée si le nom de la classe est stockée dans une chaîne de caractères qui peut changer à l'exécution. Cela fonctionne lorsque nomClasse est
bien le nom d'une classe ou d'une interface. Dans le cas contraire, la méthode forName() lance une exception vérifiée.
Obtenir une classe au moyen du suffixe .class
Une troisième technique emploie un raccourci pratique pour obtenir un objet de type Class. En effet, si Test d'un type Java quelconque, alors T.class représente
l'objet classe correspondant.
Class cl1 = Personne.class ;// Pour le suffixe .class il faut importer java.util.*;
Class cl2 = int.class ;
Class cl3 = Double[].class ;
Remarquez qu'un objet Class désigne en réalité un type, qui n'est pas nécessairement une classe. Par exemple, int n'est pas une classe, mais int.class est pourtant
un objet de type Class.
Détermination des caractéristiques d'une classe
Les trois premières caractéristiques d'une classe sont ses attributs (ou champs), ses méthodes et ses constructeurs.
Pour des raisons de description ou d'accès à un objet, elles sont représentées dans l'API de reflexion par des classes
séparées. Nous pouvont rechercher ces membres de classe en utilisant l'objet Class :
1. java.lang.reflect.Field : pour les champs (attributs).
2. java.lang.reflect.Method : pour les méthodes.
3. java.lang.reflect.Constructor : pour les constructor.
La classe Class propose deux paires de méthodes permettant d'atteindre chaque caractéristiques. Une paire
autorise l'accès aux fonctionnalités publiques d'une classe (y compris celles héritées de ses classes mères), l'autre
permettant l'accès à tout élément public ou non, déclaré directement à l'intérieur de la classe (mais pas aux
fonctionnalités hérités), selon les considérations de sécurité. Voici quelques exemples :
1. getFields() : renvoie un tableau d'objets Field représentant tous les attributs (champs) publiques d'une classe, y
compris celles héritées ;
2. getDeclaredFields() : renvoie un tableau représentant toutes les variables déclarées dans la classe, quels que
soient leurs modificateurs d'accès, mais non comprises les attributs hérités ;
3. Pour les constructeurs, la distinction entre "tous les constructeurs" et "les constructeurs déclarés" n'est pas
significative (les classes n'héritent pas des constructeurs). Par conséquent, getConstructors() et
getDeclaredConstructors() ne diffèrent que par le fait que la première renvoie les constructeurs publics et la
seconde tous les constructeurs de la classe.
Chaque paire de méthodes comporte une méthode permettant de lister tous les éléments à la fois, par exemple
getFields(), et une méthode permettant de rechercher un élément particulier par son nom et, pour les méthodes et
les constructeurs, par signature, par exemple, getField(), qui prend le nom de l'attribut comme argument.
La reflexion pour analyser les caractéristiques d'une classe
Les trois classes Field,Method,Constructor, qui se trouvent dans le paquetage java.lang.reflect, décrivent
respectivement les attributs, les méthodes et les constructeurs d'une classe. Ces trois classes disposent d'une méthode
getName() qui renvoie le nom de l'élément.
1. La classe Field possède une méthode getType() renvoyant un objet, de type Class, qui décrit le type de l'attribut.
2. Les classes Method et Constructor possèdent des méthodes permettant d'obtenir les types des paramètres, et
la classe Method signale aussi le type de retour.

Obtient tous les constructeurs publics et
non publics de cette classe. Cette
méthode renvoie un tableau d'objets
Constructor représentant tous les
constructeurs de la classe désignée par
cet objet Class.
Constructor getDeclaredConstructor
(Class... types)
Obtient le constructeur indiqué, public
ou non public, dont les arguments
correspondent aux types indiqués dans
types.
static Class forName(String nomClasse)
Renvoie l'objet Class qui représente la
classe désignée par nomClasse.
La classe Modifier
Résultats
init:
deps-jar:
Compiling 1 source file to L:\BTS IRIS\TP
Java\reflexion\build\classes
compile:
run:
Nom de la classe :
java.awt.Point
Classe de base --------------------------------
class java.awt.geom.Point2D
Attributs -------------------------------------
public int x;
public int y;
private static final long serialVersionUID;
Constructeurs ---------------------------------
public java.awt.Point(int, int);
public java.awt.Point();
public java.awt.Point(java.awt.Point);
Méthodes --------------------------------------
boolean public equals(java.lang.Object);
class java.lang.String public toString();
class java.awt.Point public getLocation();
double public getX();
double public getY();
void public move(int, int);
void public setLocation(double, double);
void public setLocation(int, int);
void public setLocation(java.awt.Point);
void public translate(int, int);
BUILD SUCCESSFUL (total time: 2 seconds)
Accès aux champs
Les trois classes possèdent également une méthode appelée getModifiers() : elle renvoie un entier dont les bits
sont utilisés comme sémaphores pour décrire les modificateurs spécifiés, tels que public ou static. Vous pouvez
alors utiliser les méthodes statiques de la classe Modifier du paquetage java.lang.reflect pour analyser les entiers
renvoyés par getModifiers(). Par exemple, il existe des méthodes telles que isPublic(),isPrivate() ou isFinal()
pour déterminer si un constructeur ou une méthode a été déclarée public,private ou final.
Il vous suffit d'appeler la méthode appropriée de Modifier et de l'utiliser sur l'entier renvoyé par getModifiers(). Il
est également possible d'employer Modifier.toString() pour afficher l'ensemble des modificateurs.
1. Les méthodes getFields(),getMethods() et getConstructors() de la classe Class renvoient dans des tableaux les attributs publics, les méthodes et les
constructeurs gérés par la classe. Ces éléments sont des objets de la classe correspondante de java.lang.reflect. Cela inclut les membres publics des
superclasses.
2. Les méthodes getDeclaredFields(),getDeclaredMethods() et getDeclaredConstructors() de Class renvoient des tableaux constitués de tous les attributs, méthodes
et constructeurs déclarés dans la classe, y compris les membres privés et protégés, mais pas les membres des superclasses.
import java.util.*;
import java.lang.reflect.*;
import static java.lang.System.*;
public class Reflexion {
public static void main(String[] args) throws Exception {
Scanner clavier = new Scanner(in);
out.println("Nom de la classe : ");
String nomClasse = clavier.next();
Class classe = Class.forName(nomClasse);
// affiche la superclasse
out.println("Classe de base --------------------------------");
out.println(" "+classe.getSuperclass());
// affiche tous les attributs
out.println("Attributs -------------------------------------");
for (Field attribut : classe.getDeclaredFields()) {
out.print(" "+Modifier.toString(attribut.getModifiers()));
out.println(" "+attribut.getType()+" "+attribut.getName()+";");
}
// affiche tous les consructeurs
out.println("Constructeurs ---------------------------------");
for (Constructor constructeur : classe.getDeclaredConstructors()) {
out.print(" "+Modifier.toString(constructeur.getModifiers()));
out.print(" "+constructeur.getName()+"(");
Class[] typeParamètres = constructeur.getParameterTypes();
for (int i=0; i<typeParamètres.length; i++) {
if (i>0) out.print(", ");
out.print(typeParamètres[i].getName());
}
out.println(");");
}
// affiche toutes les méthodes
out.println("Méthodes --------------------------------------");
for (Method méthode : classe.getDeclaredMethods()) {
out.print(" "+méthode.getReturnType()+" ");
out.print(Modifier.toString(méthode.getModifiers()));
out.print(" "+méthode.getName()+"(");
Class[] typeParamètres = méthode.getParameterTypes();
for (int i=0; i<typeParamètres.length; i++) {
if (i>0) out.print(", ");
out.print(typeParamètres[i].getName());
}
out.println(");");
}
}
}
La réflexion pour l'analyse des objets à l'exécution
Dans la section précédente, nous avons vu comment trouver le nom et le type des attributs de n'importe quel objet en
suivant la procédure suivante :
1. Obtenir l'objet Class correspondant ;
2. Appeler getDeclaredFields() sur l'objet Class.
Dans cette section, nous allons franchir une étape supplémentaire et étudier le contenu des attributs.

Sécurité
Les accès à l'API de reflexion sont contrôlés
par un gestionnaire de sécurité. Une
application complètement sécurisée a accès
à toutes les fonctionnalités vues
précédemment ; elle peut accéder aux
membres de classes au niveau de restriction
accordé au code compris dans sa portée. Il
est toutefois possible de fournir des accès
privilégiés au code, afin qu'il puisse utiliser
l'API de réflexion et accéder à des
memebres protégés et privés d'autres
classes, ce qui est normalement interdit par
le langage Java.
Les classes Field,Method et Constructor sont
toutes des extensions de la classe de base
AccessibleObject. La classe AccessibleObject
possède une méthode fondamentale,
appelée setAccessible(), qui permet de
désactiver la sécurité d'accès. à un membre
particulier d'une classe. cela semble trop
facile. C'est effectivement facile, mais le fait
que cette méthode vous permettent ou pas
de désactiver la sécurité est une
fonctionnalité du gestionnaire de sécurité
Java et des règles associées. Vous pouvez le
faire uniquement dans une application Java
qui fonctionne sans aucune règle de
sécurité.
Récupération des valeurs primitives
La classe java.lang.reflect.Field représente
les attributs des objets. Field possède un jeu
complet de méthode d'accès surchargées
pour tous les types de base, par exemple
getInt() et setInt(),getBoolean() et
setBoolean() et des méthodes get() et set()
pour accéder à des attributs qui font
références à des objets.
import java.lang.reflect.*;
import static java.lang.System.*;
class Banque {
public int balance = 25;
}
public class Main {
public static void main(String[] args)
throws Exception {
Banque compte = new CompteBancaire
();
Field at = Banque.class.getField
("balance");
int balance = at.getInt(compte);
out.println("Balance = "+balance);
at.setInt(compte, 42);
out.println("Balance = "+at.getInt
(compte));
}
}
Dans cet exemple, nous sommes supposés
déjà connaître la structure de l'objet Banque.
En règle général, nous devrions pouvoir
récupérer cette information à partir de
l'objet même.
Toutes les données des méthodes d'accès de
Field prennent une référence sur l'objet
auquel nous voulons accéder. Dans le code
ci-dessus, la méthode getField() renvoie un
objet Field représentant l'attribut balance de
la classe Banque ; cet objet Field ne fait pas
référence à un objet Banque particulier. Par
conséquent, pour lire ou modifier un objet de
type Banque spécifique, nous appelons
getInt() et setInt() avec une référence à
compte, qui est le compte précis sur lequel
nous désirons travailler.
Bien entendu, il est facile de lire le contenu d'un champ spécifique d'un objet dont le nom et le type sont connus
lors de l'écriture du programme. Mais la réflexion permet de lire les attributs des objets qui n'étaient pas connus
au moment de la compilation.
Récupération des valeurs des attributs par la méthode get()
A cet égard, la méthode essentielle est la méthode get() de la classe Field. Si attribut est un objet de type Field
obtenu au moyen de la méthode getDeclaredFields() et moi un objet de la classe dont attribut est un attribut,
alors attribut.get(moi)renvoie un objet dont la valeur est la valeur courante de l'attribut de l'objet moi :
package test;
import java.lang.reflect.*;
public class Main {
public static void main(String[] args) throws Exception {
Personne moi = new Personne("REMY", "Emmanuel", 46);
Class classe = moi.getClass();
Field attribut = classe.getDeclaredField("nom");
Object valeur = attribut.get(moi);
System.out.println(valeur);
}
}
class Personne {
private String nom, prénom;
private int âge;
public Personne(String nom, String prénom, int âge) {
this.nom = nom;
this.prénom = prénom;
this.âge = âge;
}
}
// Résultat : Exception de type IllegalAccessException
En réalité, ce code pose un problème. Comme l'attribut moi est privé, la méthode get() déclenche une exception
IllegalAccessException. Cette méthode ne peut être employée que pour obtenir les valeurs des champs
accessibles. Le mécanisme de sécurité Java vous permet de connaître les champs d'un objet, mais pas de lire la
valeur de ces champs si vous n'avez pas une autorisation d'accès.
Accessibilité des attributs
Par défaut, le mécanisme de réflexion respecte le contrôle des accès. Néanmoins, si un programme Java n'est pas
contrôlé par un gestionnaire de sécurité qui le lui interdit, il peut outrepasser son droit d'accès. Pour cela, il faut
invoquer la méthode setAccessible() d'un objet Field,Method ou Constructor :
attribut.setAccessible(true);
La méthode setAccessible() se trouve dans la classe AccessibleObject, qui est la superclasse commune des
classes Field,Method ou Constructor. Cette fonctionnalité est destinée au débogage, au stockage permanent et à
des mécanismes similaires.
package test;
import java.lang.reflect.*;
public class Main {
public static void main(String[] args) throws Exception {
Personne moi = new Personne("REMY", "Emmanuel", 46);
Class classe = moi.getClass();
Field attribut = classe.getDeclaredField("nom");
attribut.setAccessible(true);
Object valeur = attribut.get(moi);
System.out.println(valeur);
}
}
class Personne {
private String nom, prénom;
private int âge;
public Personne(String nom, String prénom, int âge) {
this.nom = nom;
this.prénom = prénom;
this.âge = âge;
}
}
// Résultat : REMY
Récupération des valeurs de type primitif
La méthode get() pose un second problème. Dans notre exemple, l'attribut nom est de type String, il est donc
possible de récupérer la valeur en tant que Object. Mais supposons que nous désirions étudier l'attribut âge.
Celui-ci est de type primitif int, et les nombres ne sont pas des objets en Java. Il existe deux solutions :
1. La première consiste à utiliser la méthode getInt() de la classe Field ;
2. la seconde est un appel à get(), car le mécanisme de réflexion enveloppe automatiquement la valeur du champ
dans la classe enveloppe appropriée, en l'occurence Integer.
L'exemple ci-dessous permet d'exploiter ces deux possibilités, ou même de travailler avec la classe de base
Object :
package test;
import java.lang.reflect.*;
public class Main {
public static void main(String[] args) throws Exception {
Personne moi = new Personne("REMY", "Emmanuel", 46);
Class classe = moi.getClass();
Field attribut = classe.getDeclaredField("âge");
attribut.setAccessible(true);
Object objet = attribut.get(moi); // première solution
System.out.println(objet);
int entier = (Integer) attribut.get(moi); // deuxième solution
System.out.println(entier);
int valeur = attribut.getInt(moi); // troisième solution

Ici, nous ne faisons rien d'autre que
ce que nous aurions pu faire avec un
code statique à la compilation.
L'important, c'est que nous pouvons
accéder à balance en cours
d'exécution, dans une classe chargée
dynamiquement.
Résultat
init:
deps-jar:
Compiling 1 source file to C:\netbeans-
5.0\travail\Test\build\classes
compile:
run:
46
46
46
BUILD SUCCESSFUL (total time: 3 seconds)
Résultats
init:
deps-jar:
Compiling 1 source file to L:\BTS IRIS\TP
Java\reflexion\build\classes
compile:
run:
Nom de la classe :
java.awt.Point
Classe de base --------------------------------
class java.awt.geom.Point2D
Attributs -------------------------------------
public int x = 0;
public int y = 0;
private static final long serialVersionUID =
-5276940640259749850 ;
Constructeurs ---------------------------------
public java.awt.Point(int, int);
public java.awt.Point();
public java.awt.Point(java.awt.Point);
Méthodes --------------------------------------
boolean public equals(java.lang.Object);
class java.lang.String public toString();
class java.awt.Point public getLocation();
double public getX();
double public getY();
void public move(int, int);
void public setLocation(double, double);
void public setLocation(int, int);
void public setLocation(java.awt.Point);
void public translate(int, int);
BUILD SUCCESSFUL (total time: 3 seconds)
Accès aux méthodes
La classe java.lang.reflect.Method
représente une méthode statique (de classe)
ou une simple méthode issue d'un objet.
Résultats
init:
deps-jar:
Compiling 1 source file to L:\BTS IRIS\TP
Java\test\build\classes
compile:
System.out.println(valeur);
}
}
class Personne {
private String nom, prénom;
private int âge;
public Personne(String nom, String prénom, int âge) {
this.nom = nom;
this.prénom = prénom;
this.âge = âge;
}
}
Changement de la valeur d'un attribut
Bien entendu, il est possible de modifier des valeurs obtenues. L'appel attribut.set(objet, valeur) affecte une
nouvelle valeur à l'attribut de l'objet.
Exemple qui visualise la valeur des attributs sur un objet créé avec le constructeur par défaut
La création d'une nouvelle instance (nouvel objet) est réalisé au travers de la méthode newInstance() de la classe
Class. Cette méthode est étudiée un peu plus loin.
import java.util.*;
import java.lang.reflect.*;
import static java.lang.System.*;
public class Reflexion {
public static void main(String[] args) throws Exception {
Scanner clavier = new Scanner(in);
out.println("Nom de la classe : ");
String nomClasse = clavier.next();
Class classe = Class.forName(nomClasse);
Object objet = classe.newInstance();
// affiche la superclasse
out.println("Classe de base --------------------------------");
out.println(" "+classe.getSuperclass());
// affiche tous les attributs
out.println("Attributs -------------------------------------");
for (Field attribut : classe.getDeclaredFields()) {
out.print(" "+Modifier.toString(attribut.getModifiers()));
out.print(" "+attribut.getType()+" "+attribut.getName
()+" = ");
attribut.setAccessible(true);
out.println(attribut.get(objet)+";");
}
// affiche tous les consructeurs
out.println("Constructeurs ---------------------------------");
for (Constructor constructeur :
classe.getDeclaredConstructors()) {
out.print(" "+Modifier.toString(constructeur.getModifiers
()));
out.print(" "+constructeur.getName()+"(");
Class[] typeParamètres =
constructeur.getParameterTypes();
for (int i=0; i<typeParamètres.length; i++) {
if (i>0) out.print(", ");
out.print(typeParamètres[i].getName());
}
out.println(");");
}
// affiche toutes les méthodes
out.println("Méthodes --------------------------------------");
for (Method méthode : classe.getDeclaredMethods()) {
out.print(" "+méthode.getReturnType()+" ");
out.print(Modifier.toString(méthode.getModifiers()));
out.print(" "+méthode.getName()+"(");
Class[] typeParamètres = méthode.getParameterTypes();
for (int i=0; i<typeParamètres.length; i++) {
if (i>0) out.print(", ");
out.print(typeParamètres[i].getName());
}
out.println(");");
}
}
}
Les pointeurs de méthodes
Les pointeurs de méthodes permettent de fournir l'adresse d'une méthode à une autre méthode, afin que la seconde
puisse appeler la première. Pour voir à l'oeuvre les pointeurs de méthodes, rappelez-vous que vous pouvez inspecter un
attribut à l'aide de la méthode get() de la classe Field. Pour sa part, la classe Method dispose d'une méthode invoke()
permettant d'appeler la méthode enveloppée dans l'objet Method. La signature de la méthode invoke() est la suivante :
Object Method.invoke(Object obj,Object... args);
Le premier paramètre est implicite, il s'agit de l'objet (si il est créé) qui possède cette méthode. Les autres objets
fournissent les éventuels paramètres explicites de la méthode invoquée.
Dans le cas d'une méthode statique, le premier paramètre est ignoré, il peut recevoir la valeur null.
.
Voici un exemple qui permet de lancer la méthode getNom() (sans arguments) de la classe Personne :
package test;
import java.lang.reflect.*;
public class Main {
public static void main(String[] args) throws Exception {
Personne moi = new Personne("REMY", "Emmanuel", 46);
Class classe = moi.getClass();
Method nom = classe.getDeclaredMethod("getNom");
System.out.println("Nom : "+nom.invoke(moi));
int âge = (Integer) classe.getDeclaredMethod("getAge").invoke(moi);