En Java, la réflexion fait principalement référence à la capacité d'un programme à accéder, détecter et modifier son propre état ou comportement. Les principales fonctions du mécanisme de réflexion Java : 1. Déterminer la classe à laquelle appartient tout objet au moment de l'exécution ; 2. Construire un objet de n'importe quelle classe au moment de l'exécution ; 3. Appeler la méthode de n'importe quel objet au moment de l'exécution, etc.
L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur DELL G3.
Se réfère principalement à la capacité d'un programme à accéder, détecter et modifier son propre état ou comportement
Dans l'environnement d'exécution Java, pour n'importe quelle classe, pouvez-vous connaître les propriétés et les méthodes de cette classe ? Pour n'importe quel objet, l'une de ses méthodes peut-elle être appelée ?
Le mécanisme de réflexion Java fournit principalement les fonctions suivantes :
* 1. Déterminer la classe à laquelle appartient tout objet au moment de l'exécution.
* 2. Construisez un objet de n'importe quelle classe au moment de l'exécution.
* 3. Déterminez les variables membres et les méthodes de n'importe quelle classe au moment de l'exécution.
* 4. Appelez la méthode de n'importe quel objet au moment de l'exécution.
La réflexion est une propriété clé de Java étant considéré comme un langage dynamique (ou quasi-dynamique).
Ce mécanisme permet au programme d'obtenir les informations internes de toute classe avec un nom connu via les API Reflection au moment de l'exécution.
Inclut toutes les informations sur ses modificateurs (tels que public, static, etc.), sa superclasse (telle que Object), les interfaces implémentées (telles que Serialisable), ainsi que ses champs et méthodes, et peut modifier le contenu des champs au moment de l'exécution ou appelez des méthodes.
La définition du langage dynamique "Lorsqu'un programme est en cours d'exécution, il est permis de changer la structure du programme ou le type de variable. Ce langage est appelé un langage dynamique langue."
De ce point de vue, Perl, Python et Ruby sont des langages dynamiques, tandis que C++, Java et C# ne sont pas des langages dynamiques.
Bien que Java ne soit pas un langage dynamique selon cette définition et classification, il possède un mécanisme dynamique très important : la réflexion. Ce mot signifie : réflexion, image, réflexion. Lorsqu'il est utilisé en Java, cela signifie que nous pouvons charger, détecter et utiliser des classes au moment de l'exécution qui sont complètement inconnues lors de la compilation.
En d'autres termes, un programme Java peut charger une classe dont le nom n'est connu qu'au moment de l'exécution, apprendre sa structure complète (mais sans inclure les définitions de méthode) et générer ses entités d'objet, ou définir des valeurs pour ses champs, ou Evoke ses méthodes.
La capacité du programme à s'examiner lui-même est appelée introspection. Réflexion et introspection sont deux termes souvent mentionnés ensemble.
Dans le JDK, le mécanisme de réflexion Java est principalement implémenté par les classes suivantes. Ces classes (sauf la première) sont toutes localisées. dans java.lang.
dans le package Reflect Class Class : représente une classe et se trouve sous le package Java.lang.
Classe Field : représente les variables membres de la classe (les variables membres sont également appelées attributs de la classe).
Classe de méthode : représente la méthode de la classe.
Classe constructeur : représente la méthode de construction de la classe.
Classe Array : fournit des méthodes statiques pour créer dynamiquement des tableaux et accéder aux éléments des tableaux.
Pour utiliser la réflexion, il faut d'abord obtenir l'objet Classe correspondant à la classe sur laquelle opérer.
En Java, quel que soit le nombre d'objets d'une certaine classe générés, ces objets correspondront au même objet Class.
Cet objet Class est généré par la JVM, à travers laquelle la structure de la classe entière peut être apprise.
Trois façons couramment utilisées pour obtenir des objets Class :
1 Utilisez la méthode statique de la classe Class. Par exemple :
Class.forName(“java.lang.String”);
2. Utilisez la syntaxe .class de la classe. Tels que :
String.class;
3. Utilisez la méthode getClass() de l'objet. Tels que :
String str = “aa”; Class
Routine 1 : Méthode Get
La classe Routine DumpMethods illustre la fonction de base de l'API Reflection, qui lit la ligne de commande. nom de classe spécifié par le paramètre, puis imprime les informations de méthode de cette classe.
import java.lang.reflect.Method;
public class DumpMethods
{
public static void main(String[] args) throws Exception //在方法后加上这句，异常就消失了
{
//获得字符串所标识的类的class对象
Class<?> classType = Class.forName("java.lang.String");//在此处传入字符串指定类名，所以参数获取可以是一个运行期的行为，可以用args[0]
//返回class对象所对应的类或接口中，所声明的所有方法的数组（包括私有方法）
Method[] methods = classType.getDeclaredMethods();
//遍历输出所有方法声明
for(Method method : methods)
{
System.out.println(method);
}
}
}Routine 2 : Appeler la méthode par réflexion
Appeler la méthode par réflexion. Voir le code et les commentaires pour plus de détails :
import java.lang.reflect.Method;
public class InvokeTester
{
public int add(int param1, int param2)
{
return param1 + param2;
}
public String echo(String message)
{
return "Hello: " + message;
}
public static void main(String[] args) throws Exception
{
// 以前的常规执行手段
InvokeTester tester = new InvokeTester();
System.out.println(tester.add(1, 2));
System.out.println(tester.echo("Tom"));
System.out.println("---------------------------");
// 通过反射的方式
// 第一步，获取Class对象
// 前面用的方法是：Class.forName()方法获取
// 这里用第二种方法，类名.class
Class<?> classType = InvokeTester.class;
// 生成新的对象：用newInstance()方法
Object invokeTester = classType.newInstance();
System.out.println(invokeTester instanceof InvokeTester); // 输出true
// 通过反射调用方法
// 首先需要获得与该方法对应的Method对象
Method addMethod = classType.getMethod("add", new Class[] { int.class,
int.class });
// 第一个参数是方法名，第二个参数是这个方法所需要的参数的Class对象的数组
// 调用目标方法
Object result = addMethod.invoke(invokeTester, new Object[] { 1, 2 });
System.out.println(result); // 此时result是Integer类型
//调用第二个方法
Method echoMethod = classType.getDeclaredMethod("echo", new Class[]{String.class});
Object result2 = echoMethod.invoke(invokeTester, new Object[]{"Tom"});
System.out.println(result2);
}
}Si vous souhaitez générer des objets via la méthode constructeur d'une classe sans paramètres, nous avons deux manières :
1. Obtenez d'abord l'objet Class, puis générez-le directement via la méthode newInstance() de l'objet Class :
Class<?> classType = String.class; Object obj = classType.newInstance();
2 Obtenez d'abord l'objet Class, puis obtenez l'objet Class correspondant. Objet Constructeur via l'objet. Générez ensuite
via la méthode newInstance() de l'objet Constructor (où Customer est une classe personnalisée avec un constructeur sans paramètre et un constructeur paramétré) :
Class<?> classType = Customer.class;
// 获得Constructor对象,此处获取第一个无参数的构造方法的
Constructor cons = classType.getConstructor(new Class[] {});
// 通过构造方法来生成一个对象
Object obj = cons.newInstance(new Object[] {});Si vous souhaitez générer un objet via le constructeur paramétré d'une classe, vous ne pouvez utiliser que la méthode suivante :
(Le client est une classe personnalisée avec un constructeur sans paramètre et un constructeur paramétré. Méthode, transmettre des chaînes et des entiers)
Class<?> classType = Customer.class;
Constructor cons2 = classType.getConstructor(new Class[] {String.class, int.class});
Object obj2 = cons2.newInstance(new Object[] {"ZhangSan",20});可以看出调用构造方法生成对象的方法和调用一般方法的类似，不同的是从Class对象获取Constructor对象时不需要指定名字，而获取Method对象时需要指定名字。
相关视频教程推荐：Java视频教程
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
