Comment utiliser la réflexion du langage Java

Le langage Java est un langage de programmation orienté objet, qui présente les avantages d'une bonne multiplateforme et d'une maintenance facile. Le mécanisme de réflexion du langage Java est une fonctionnalité importante du langage Java. Il permet au programme d'obtenir dynamiquement des informations sur une certaine classe au moment de l'exécution et d'utiliser les méthodes et les attributs fournis par la classe, améliorant ainsi l'évolutivité et la flexibilité du programme. Cet article explique comment utiliser la réflexion du langage Java.

Le mécanisme de réflexion est un mécanisme dynamique du langage Java, qui permet aux programmeurs d'obtenir dynamiquement des informations de classe lors de l'écriture de code, y compris les constructeurs de classe, les méthodes et les propriétés, etc. Le mécanisme de réflexion du langage Java se compose principalement de trois classes : Classe, Constructeur et Méthode. Parmi eux, Class représente le type de la classe, Constructor représente le constructeur de la classe et Method représente la méthode de la classe.

Grâce à l'objet de classe Class, nous pouvons obtenir les informations complètes de la classe, y compris le nom de la classe, la classe parent, l'interface, la méthode constructeur, la méthode membre, les attributs du membre, les annotations, etc. Par exemple, le code suivant montre l'obtention du nom de classe et du nom de classe parent d'une classe :

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Class<Person> pClass = Person.class;
        System.out.println("类名：" + pClass.getName());
        System.out.println("父类名：" + pClass.getSuperclass().getName());
    }
}

Dans le code ci-dessus, nous obtenons la Class de la classe Person via <code>Person.class code> tapez, vous pouvez alors utiliser la méthode getName() pour obtenir le nom de la classe, utilisez la méthode getSuperClass() pour obtenir la classe parent de la classe , et enfin afficher le nom de la classe et le nom de la classe parent. Person.class获取到Person类的Class类型，然后可以使用getName()方法获取该类的名称，使用getSuperClass()方法获取该类的父类，最终输出类名和父类名称。

除了获取类名和父类名称，我们还可以通过反射获取其它类的信息，例如获取类的构造器、成员方法、成员属性等等，下面的代码演示了如何获取Person类的构造器、成员变量和成员方法，并通过反射来调用它们：

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<Person> pClass = Person.class;
        // 获取所有构造器
        Constructor<?>[] constructors = pClass.getDeclaredConstructors();
        // 获取指定的构造器
        Constructor<?> constructor = pClass.getDeclaredConstructor(String.class, int.class);
        // 新建对象
        Person person = (Person) constructor.newInstance("Tom", 20);
        // 获取所有成员变量
        Field[] fields = pClass.getDeclaredFields();
        // 获取指定的成员变量
        Field field = pClass.getDeclaredField("name");
        // 修改成员变量的值
        field.setAccessible(true);
        field.set(person, "Jerry");
        // 获取所有成员方法
        Method[] methods = pClass.getDeclaredMethods();
        // 获取指定的成员方法
        Method method = pClass.getDeclaredMethod("sayHello");
        // 调用成员方法
        method.invoke(person);
    }
}

在上面的代码中，我们使用getDeclaredConstructors()方法获取到Person类的所有构造器，然后使用getDeclaredConstructor(String.class, int.class)获取到指定构造器，使用newInstance()方法新建对象。接着，我们使用getDeclaredFields()方法获取到Person类的所有成员变量，使用getDeclaredField("name")方法获取到指定成员变量，并使用setAccessible(true)方法调用私有成员变量。最后，我们使用getDeclaredMethods()方法获取到Person类的所有成员方法，使用getDeclaredMethod("sayHello")方法获取到指定成员方法，并使用invoke()

En plus d'obtenir le nom de la classe et le nom de la classe parent, nous pouvons également obtenir des informations sur d'autres classes par réflexion, comme l'obtention du constructeur, des méthodes membres, des attributs des membres, etc. de la classe. le constructeur et les membres des variables et méthodes membres de la classe Person, et les appelons par réflexion :

rrreee

Dans le code ci-dessus, nous utilisons la méthode getDeclaredConstructors() pour obtenir tous les constructeurs de la classe Person , puis utilisez getDeclaredConstructor( String.class, int.class)Obtenez le constructeur spécifié et utilisez la méthode newInstance() pour créer un nouvel objet. Ensuite, nous utilisons la méthode getDeclaredFields() pour obtenir toutes les variables membres de la classe Person, utilisons la méthode getDeclaredField("name") pour obtenir les variables membres spécifiées, et utilisez La méthode setAccessible(true) appelle des variables membres privées. Enfin, nous utilisons la méthode getDeclaredMethods() pour obtenir toutes les méthodes membres de la classe Person, utilisons la méthode getDeclaredMethod("sayHello") pour obtenir la méthode membre spécifiée, et use La méthode Invoke() appelle les méthodes membres.

1. Lorsque vous utilisez le mécanisme de réflexion, vous devez faire attention aux points suivants :
2. Les performances du mécanisme de réflexion sont inférieures car il doit obtenir les informations de la classe au moment de l'exécution, et ces informations ont été déterminées à la compilation temps, donc lorsque cela est possible, l'utilisation d'un mécanisme de réflexion doit être évitée autant que possible.
3. Le mécanisme de réflexion peut accéder et modifier les propriétés privées et les méthodes privées de la classe, ce qui rompt l'encapsulation de la classe et doit être utilisé avec prudence pour éviter les effets indésirables.

Le mécanisme de réflexion doit gérer les exceptions, telles que NoSuchMethodException, IllegalAccessException, etc., vous devez donc faire attention à la gestion des exceptions lorsque vous utilisez le mécanisme de réflexion.

🎜🎜En bref, le mécanisme de réflexion du langage Java est une fonctionnalité très importante. Il permet au programme d'obtenir dynamiquement des informations de classe et d'utiliser les méthodes et attributs de la classe, améliorant ainsi l'évolutivité et la flexibilité du programme. Lorsque vous utilisez le mécanisme de réflexion, vous devez prêter attention à des problèmes tels que les performances, l'encapsulation et la gestion des exceptions pour garantir la qualité et la fiabilité du code. 🎜

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!