Révéler les trois implémentations différentes de Java Reflection

Déchiffrez les trois méthodes d'implémentation de la réflexion Java

Introduction :
Le mécanisme de réflexion Java fait référence à l'obtention dynamique d'informations sur la classe et à l'exploitation des membres de la classe au moment de l'exécution, y compris les constructeurs, les méthodes, les champs, etc. Grâce à la réflexion, nous pouvons obtenir la structure complète d'une classe au moment de l'exécution et instancier des objets, appeler des méthodes et accéder aux champs via des chaînes sans connaître le nom spécifique de la classe. L'implémentation du mécanisme de réflexion Java repose principalement sur trois méthodes, à savoir l'objet Classe, l'objet Constructeur et l'objet Méthode. Cet article présentera les méthodes de mise en œuvre spécifiques de ces trois méthodes et fournira des exemples de code correspondants.

1. Implémentation de réflexion basée sur l'objet Class
En Java, lorsque chaque classe est chargée, un objet Class correspondant sera généré Grâce à cet objet Class, nous pouvons obtenir le nom, le modificateur, la classe parent et l'interface de la classe. et d'autres informations, et peut utiliser cet objet pour instancier des objets, appeler des méthodes dans des classes, etc.

Ce qui suit est un exemple de code pour l'implémentation de la réflexion basée sur l'objet Class :

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过类的全限定名获取Class对象
        Class<?> clazz = Class.forName("com.example.Person");
        
        // 获取类名
        String className = clazz.getName();
        System.out.println(className);
        
        // 获取修饰符
        int modifiers = clazz.getModifiers();
        System.out.println(Modifier.toString(modifiers));
        
        // 获取父类
        Class<?> superClass = clazz.getSuperclass();
        System.out.println(superClass.getName());
        
        // 获取接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> in : interfaces) {
            System.out.println(in.getName());
        }
        
        // 实例化对象
        try {
            Object obj = clazz.newInstance();
            System.out.println(obj);
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

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

2. Implémentation de la réflexion basée sur l'objet Constructor
L'objet Constructor est un objet utilisé pour obtenir les informations de constructeur d'une classe dans le mécanisme de réflexion Java. l'objet Constructor, nous pouvons obtenir les modificateurs, les types de paramètres et d'autres informations du constructeur, et utiliser cet objet pour instancier des objets de la classe.

Ce qui suit est un exemple de code pour l'implémentation de la réflexion basée sur l'objet Constructor :

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> clazz = Class.forName("com.example.Person");
        
        // 获取所有公共构造函数
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        
        // 获取指定参数类型的构造函数
        Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor);
        
        // 实例化对象
        try {
            Object obj = constructor.newInstance("Tom", 25);
            System.out.println(obj);
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

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

3. Implémentation de la réflexion basée sur l'objet Method
L'objet Method est un objet utilisé pour obtenir des informations sur la méthode d'une classe dans le mécanisme de réflexion Java que nous pouvons obtenir. via l'objet méthode Modificateurs de méthode, types de valeurs de retour, types de paramètres et autres informations, et vous pouvez utiliser cet objet pour appeler des méthodes dans la classe.

Ce qui suit est un exemple de code pour l'implémentation de la réflexion basée sur l'objet Method :

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class<?> clazz = Class.forName("com.example.Person");
        
        // 获取所有公共方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        
        // 获取指定方法
        Method method = clazz.getMethod("sayHello");
        System.out.println(method);
        
        // 调用方法
        try {
            Object obj = clazz.newInstance();
            method.invoke(obj);
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

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

Résumé :
Le mécanisme de réflexion Java fournit un moyen d'exploiter dynamiquement les classes au moment de l'exécution, nous permettant de passer à travers sans connaître le nom de classe spécifique vers. instancier des objets, des méthodes d'appel, des champs d'accès, etc. Cet article présente trois méthodes d'implémentation de réflexion basées sur des objets Class, des objets Constructor et des objets Method, et fournit des exemples de code correspondants à titre de référence. L'utilisation du mécanisme de réflexion Java peut rendre notre code plus flexible et évolutif, mais dans le développement réel, nous devons prêter attention à la pertinence et à la sécurité de l'utilisation de la réflexion pour éviter les risques inutiles et les pertes de performances.

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!