Revealing the Three Different Implementations of Java Reflection

Decrypt the three implementation methods of Java reflection

Introduction:
Java reflection mechanism refers to dynamically obtaining class information and operating class members at runtime , including constructors, methods, fields, etc. Through reflection, we can obtain the complete structure of a class at runtime, and instantiate objects, call methods, and access fields through strings without knowing the specific class name. The implementation of Java reflection mechanism mainly relies on three methods, namely Class object, Constructor object and Method object. This article will introduce the specific implementation methods of these three methods and provide corresponding code examples.

1. Reflection implementation based on Class object
In Java, when each class is loaded, a corresponding Class object will be generated. Through this Class object, we can obtain the name and modification of the class. It contains information such as symbol, parent class, interface, etc., and can use this object to instantiate objects, call methods in the class, etc.

The following is a sample code for reflection implementation based on Class object:

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. Reflection implementation based on Constructor object
The Constructor object is a construct used to obtain classes in the Java reflection mechanism The object of function information. Through the Constructor object, we can obtain the modifiers, parameter types and other information of the constructor, and can use this object to instantiate the object of the class.

The following is a sample code for reflection implementation based on Constructor object:

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. Reflection implementation based on Method object
Method object is the method used to obtain classes in the Java reflection mechanism Information object. Through the Method object, we can obtain the method's modifiers, return value type, parameter type and other information, and can use this object to call methods in the class.

The following is a reflection implementation example code based on Method object:

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);
    }
}

Summary:
The Java reflection mechanism provides a means of dynamically operating classes at runtime, allowing us to Without knowing the specific class name, instantiate objects, call methods, and access fields through strings. This article introduces three reflection implementation methods based on Class objects, Constructor objects, and Method objects, and provides corresponding code examples for reference. Using the Java reflection mechanism can make our code more flexible and scalable, but in actual development, we must pay attention to the appropriateness and safety of using reflection to avoid unnecessary risks and performance losses.

The above is the detailed content of Revealing the Three Different Implementations of Java Reflection. For more information, please follow other related articles on the PHP Chinese website!