Three ways to learn Java reflection skills

Three techniques for in-depth understanding of Java reflection

Introduction: Java reflection is a powerful programming technique that can dynamically obtain class-related information at runtime. And operate the members of the class. This article will introduce three advanced techniques of Java reflection and give specific code examples.

1. Get complete information of a class

Through Java reflection, we can get complete information of a class, including class name, parent class, implemented interfaces, methods, and fields wait. The following is a sample code to obtain complete information about a class:

import java.lang.reflect.*;

public class ReflectionDemo {
    public static void main(String[] args) {
        try {
            // 获取类名
            Class<?> cls = Class.forName("com.example.MyClass");
            System.out.println("类名：" + cls.getName());

            // 获取父类名
            Class<?> superClass = cls.getSuperclass();
            System.out.println("父类名：" + superClass.getName());

            // 获取实现的接口名
            Class<?>[] interfaces = cls.getInterfaces();
            for (Class<?> anInterface : interfaces) {
                System.out.println("接口名：" + anInterface.getName());
            }

            // 获取方法名
            Method[] methods = cls.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println("方法名：" + method.getName());
            }

            // 获取字段名
            Field[] fields = cls.getDeclaredFields();
            for (Field field : fields) {
                System.out.println("字段名：" + field.getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyClass extends ParentClass implements MyInterface {
    private String name;
    public int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class ParentClass {
    // 父类代码
}

interface MyInterface {
    // 接口代码
}

Through the above code, we can obtain the class name, parent class name, implemented interface name, method name, field name and other information.

2. Dynamic creation of objects

Java reflection can also dynamically create objects at runtime. The following is a sample code for dynamically creating an object:

import java.lang.reflect.*;

public class ReflectionDemo {
    public static void main(String[] args) {
        try {
            // 获取类名
            Class<?> cls = Class.forName("com.example.MyClass");

            // 创建对象
            Object obj = cls.getDeclaredConstructor().newInstance();

            // 设置属性
            Field nameField = cls.getDeclaredField("name");
            Field ageField = cls.getDeclaredField("age");
            nameField.setAccessible(true);
            ageField.setAccessible(true);
            nameField.set(obj, "Tom");
            ageField.set(obj, 20);

            // 获取属性
            String name = (String) nameField.get(obj);
            int age = (int) ageField.get(obj);
            System.out.println("姓名：" + name);
            System.out.println("年龄：" + age);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Through the above code, we can dynamically create an object of MyClass and set the object's attribute values. Then we can get the object's property values ​​through reflection.

3. Call private methods

Through Java reflection, we can call private methods in a class. The following is a sample code for calling a private method:

import java.lang.reflect.*;

public class ReflectionDemo {
    public static void main(String[] args) {
        try {
            // 获取类名
            Class<?> cls = Class.forName("com.example.MyClass");

            // 创建对象
            Object obj = cls.getDeclaredConstructor().newInstance();

            // 获取私有方法
            Method privateMethod = cls.getDeclaredMethod("privateMethod");

            // 调用私有方法
            privateMethod.setAccessible(true);
            privateMethod.invoke(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    private void privateMethod() {
        System.out.println("这是一个私有方法");
    }
}

Through the above code, we can successfully call the private method privateMethod() in the MyClass class.

Summary:

Through the three techniques of Java reflection: obtaining complete information of the class, dynamically creating objects and calling private methods, we can dynamically obtain relevant information of the class at runtime. And operate on classes without changing existing code. This gives us greater flexibility and scalability, allowing us to write code more efficiently. However, care needs to be taken to ensure safety and performance when using reflection.

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