La réflexion est une fonctionnalité importante du langage Java.Nous savons qu'avant d'utiliser une classe, nous l'avons souvent déjà créée, comme créer un fichier de classe, puis écrire des attributs, des méthodes, etc., c'est-à-dire ce type de classe. C'est statique, mais le mécanisme de réflexion permet de créer une classe de manière dynamique. En plus de créer dynamiquement une classe, nous pouvons également obtenir dynamiquement des données d'objets similaires et attribuer ces données à la classe nouvellement créée, ce qui est quelque peu similaire au clonage. Plusieurs fois, nous avons besoin de cette fonctionnalité de création dynamique de classes. Par exemple, lors du traitement de certaines entreprises, mais ces entreprises sont légèrement différentes, elles correspondent souvent à plusieurs classes. Lors du traitement, nous devons nous baser sur différents traitements métier pour appeler différentes classes. cette fois, le mécanisme de réflexion est utile.
Voici la description du package java.lang.reflect dans l'API JDK :
Fournit des classes et des interfaces pour obtenir des informations de réflexion sur les classes et les objets. Dans le cadre des contraintes de sécurité, la réflexion permet un accès programmatique aux informations sur les champs, méthodes et constructeurs d'une classe chargée, et permet l'utilisation de champs, méthodes et constructeurs réfléchis pour opérer sur des équivalents sous-jacents sur un objet.
AccessibleObject permet de supprimer les contrôles d'accès si la ReflectPermission requise est disponible.
Les tableaux fournissent des méthodes statiques pour créer et accéder dynamiquement aux tableaux.
Les classes de ce package, ainsi que java.lang.Class, peuvent être adaptées aux besoins d'applications telles que les débogueurs, les interprètes, les inspecteurs d'objets, les navigateurs de classes et les services (tels que la sérialisation d'objets et JavaBeans) qui doivent accéder à la cible. objets basés sur des membres publics de sa classe d'exécution) ou des membres déclarés par une classe donnée).
Ce qui suit utilise deux exemples simples pour illustrer l’utilisation de la réflexion. Tout d’abord, créez une classe Person :
Copiez le code comme suit :
test de paquet ;
classe publique Personne {
âge int privé ;
nom de chaîne privé = "" ;
private String[] arr = new String[2];
Personne publique(){}
Personne publique (nom de chaîne, âge int) {
this.name = nom ;
this.age = âge;
}
public int getAge() {
âge de retour;
}
public void setAge (int âge) {
this.age = âge;
}
chaîne publique getName() {
renvoyer le nom ;
}
public void setName (nom de la chaîne) {
this.name = nom ;
}
public String[] getArr() {
retour arr;
}
public void setArr(String[] arr) {
this.arr = arr;
}
}
Exemple 1 : Obtenez les attributs et les informations de méthode de la classe Person. Copiez le code comme suit :
test de vide statique privéSimpleReflect(){
String className = "test.Person" ;
essayer {
Classe c = Class.forName(className);
Champs Field[] = c.getDeclaredFields();
Method[] m = c.getDeclaredMethods();
pour (Champ champ : champs){
System.out.println(field.getName());
}
pour (Méthode méthode : m){
System.out.println(m.getClass());
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
C'est très simple. Vous pouvez obtenir une classe via le chemin du package où se trouve la classe, c'est également le plus utilisé.
Exemple 2 : Copie d'objet Copier le code Le code est le suivant :
@SuppressWarnings("non coché")
La copie d'objet statique publique (objet objet) lève une exception {
// Récupère le type d'objet
Classe classType = object.getClass();
System.out.println("" + classType.getName()); // Crée un nouvel objet via la méthode de construction par défaut
Objet objectCopy = classType.getConstructor(new Class[] {})
.newInstance(new Object[] {}); // Récupère toutes les propriétés de l'objet
Champs de champ[] = classType.getDeclaredFields();
pour (int i = 0; i < champs.longueur; i++) {
Champ champ = champs[i];
Chaîne fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase(); // Récupère le nom de la méthode getXXX() correspondant à l'attribut
String getMethodName = "get" + firstLetter + fieldName.substring(1); // Récupère le nom de la méthode setXXX() correspondant à l'attribut
String setMethodName = "set" + firstLetter + fieldName.substring(1); // Récupère la méthode getXXX() correspondant à l'attribut
Méthode getMethod = classType.getMethod(getMethodName,
new Class[] {}); // Récupère la méthode setXXX() correspondant à l'attribut
Méthode setMethod = classType.getMethod(setMethodName,
new Class[] { field.getType() }); // Appel de la méthode getXXX() de l'objet d'origine
Valeur de l'objet = getMethod.invoke(object, new Object[] {});
System.out.println(fieldName + ":" + value); // Appel de la méthode setXXX() de l'objet copié
setMethod.invoke(objectCopy, new Object[] { valeur });
}
return objectCopie ;
}
En utilisant la réflexion pour copier des objets, nous n'avons généralement pas à le faire nous-mêmes, car le système open source BeanUtils a déjà encapsulé la copie d'objet pour nous. Nous pouvons simplement appeler sa méthode directement, mais il convient de noter que BeanUtils est également basé. sur le mécanisme de réflexion. Pour réaliser le paquet.
Voici un appel :
Copiez le code comme suit :
public static void main (String[] args){
Personne personne = new Personne("tom",22);
String[] strs = new String[]{"a","b"};
personne.setArr(strs);
essayer {
Personne p = (Personne)copie (personne);
System.out.println(p.getName()+">>"+p.getAge());
pour (String str : p.getArr()){
System.out.println(str);
}
} attraper (Exception e) {
e.printStackTrace();
}
// testSimpleReflect();
}