Three ways to learn Java reflection

Mastering the three strategies of Java reflection requires specific code examples

Introduction:
Java reflection is a powerful programming technology that allows programs to run Dynamically access and operate objects by analyzing the structure and methods of the class. Mastering Java reflection technology can not only improve the flexibility and scalability of code, but also implement some complex design patterns. This article will introduce three commonly used Java reflection strategies and give specific code examples.

Text:

1. Get class information

Through Java reflection, we can get various information about a class, including class name and parent class , implemented interfaces, member variables, constructors and methods, etc. The following example demonstrates how to use reflection to obtain basic information of a class:

public class ReflectionExample {
    public static void main(String[] args) {

        // 获取类的基本信息
        Class<Person> personClass = Person.class;
        System.out.println("类名：" + personClass.getName());
        System.out.println("父类名：" + personClass.getSuperclass().getName());
        
        // 获取类的成员变量信息
        Field[] fields = personClass.getDeclaredFields();
        System.out.println("成员变量：");
        for (Field field : fields) {
            System.out.println(field.getName() + "，类型：" + field.getType().getName());
        }
        
        // 获取类的构造方法信息
        Constructor[] constructors = personClass.getConstructors();
        System.out.println("构造方法：");
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "，参数个数：" + constructor.getParameterCount());
        }
        
        // 获取类的方法信息
        Method[] methods = personClass.getMethods();
        System.out.println("方法：");
        for (Method method : methods) {
            System.out.println(method.getName() + "，返回类型：" + method.getReturnType().getName());
        }
    }
}

class Person {
    private String name;
    private int age;
    
    public Person() {}
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHello() {
        System.out.println("Hello, I'm " + name);
    }
}

The above code first obtains the Class object of the Person class, and then obtains the name and parent class of the class through the Class object , member variables, constructors and methods and other information, and print out one by one.

2. Creating objects

Using reflection, you can dynamically create an object at runtime without knowing its specific class name in advance. The following example demonstrates how to create a Person object through reflection:

public class ReflectionExample {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        // 获取类的构造方法
        Class<Person> personClass = Person.class;
        Constructor<Person> constructor = personClass.getConstructor(String.class, int.class);

        // 创建对象
        Person person = constructor.newInstance("John", 25);
        System.out.println(person.getName());
    }
}

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

In the above code, the constructor method of the Person class is obtained through reflectionConstructor constructor = personClass.getConstructor(String.class, int.class);, and then use the constructor method to create a Person objectPerson person = constructor.newInstance("John", 25);.

3. Calling methods

Using reflection, we can dynamically call an object's method at runtime without having to determine the method name and parameter type at compile time. The following example demonstrates how to call the sayHello method of the Person class through reflection:

public class ReflectionExample {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {

        // 获取类的方法
        Class<Person> personClass = Person.class;
        Method sayHelloMethod = personClass.getMethod("sayHello");

        // 创建对象
        Person person = new Person();

        // 调用方法
        sayHelloMethod.invoke(person);
    }
}

class Person {
    public void sayHello() {
        System.out.println("Hello, I'm a person.");
    }
}

In the above code, the Person class is obtained through reflection The method Method sayHelloMethod = personClass.getMethod("sayHello");, then creates a Person object and calls the sayHellomethodsayHelloMethod.invoke (person);.

Conclusion:
By mastering the three strategies of Java reflection, we can dynamically obtain class information, create objects and call methods at runtime. This makes our code more flexible and extensible, and also provides convenience for implementing some complex design patterns. I hope the code examples in this article can help readers better understand the use of Java reflection.

The above is the detailed content of Three ways to learn Java reflection. For more information, please follow other related articles on the PHP Chinese website!