Java学习指南-第十三天：反射机制

    1.反射机制简介

    反射机制是Java提供的一种强大的工具，允许程序在运行时获取类的信息并操作类的属性和方法。通过反射，程序可以在运行时动态地创建对象、调用方法、访问字段等。

    2.获取Class对象

    在Java中，每个类都有一个对应的Class对象，用于表示该类的元数据。可以通过以下方式获取Class对象：

•     Class.forName()：通过类的全限定名获取Class对象。

•     类名.class：通过类的字面常量获取Class对象。

•     对象.getClass()：通过对象的getClass()方法获取Class对象。

    2.1获取Class对象示例

public class Main {
    public static void main(String[] args) {
        try {
            // 通过Class.forName()获取Class对象
            Class<?> clazz1 = Class.forName("java.lang.String");
            System.out.println("Class 1: " + clazz1.getName());

            // 通过类名.class获取Class对象
            Class<?> clazz2 = String.class;
            System.out.println("Class 2: " + clazz2.getName());

            // 通过对象.getClass()获取Class对象
            String str = "Hello";
            Class<?> clazz3 = str.getClass();
            System.out.println("Class 3: " + clazz3.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

    3.创建对象

    通过反射机制，可以在运行时动态地创建对象。

    3.1使用Class.newInstance()创建对象

public class Main {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");
            String str = (String) clazz.newInstance();
            System.out.println("Created object: " + str);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

    3.2使用Constructor.newInstance()创建对象

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");
            Constructor<?> constructor = clazz.getConstructor(String.class);
            String str = (String) constructor.newInstance("Hello");
            System.out.println("Created object: " + str);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    4.访问字段

    通过反射机制，可以在运行时访问和修改对象的字段。

    4.1获取和设置字段值

import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");
            String str = (String) clazz.getConstructor(String.class).newInstance("Hello");

            // 获取字段
            Field field = clazz.getDeclaredField("value");
            field.setAccessible(true);  // 设置可访问

            // 获取字段值
            char[] value = (char[]) field.get(str);
            System.out.println("Field value: " + new String(value));

            // 设置字段值
            field.set(str, "World".toCharArray());
            System.out.println("Updated field value: " + str);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    5.调用方法

    通过反射机制，可以在运行时调用对象的方法。

    5.1调用方法

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");
            String str = (String) clazz.getConstructor(String.class).newInstance("Hello");

            // 获取方法
            Method method = clazz.getMethod("toUpperCase");

            // 调用方法
            String result = (String) method.invoke(str);
            System.out.println("Method result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    6.获取类信息

    通过反射机制，可以获取类的各种信息，如类名、父类、接口、字段、方法等。

    6.1获取类信息

import java.lang.reflect.Method;
import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");

            // 获取类名
            System.out.println("Class name: " + clazz.getName());

            // 获取父类
            System.out.println("Superclass: " + clazz.getSuperclass().getName());

            // 获取接口
            Class<?>[] interfaces = clazz.getInterfaces();
            for (Class<?> iface : interfaces) {
                System.out.println("Interface: " + iface.getName());
            }

            // 获取字段
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                System.out.println("Field: " + field.getName());
            }

            // 获取方法
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println("Method: " + method.getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

    8.示例代码

// 创建对象并调用方法代码见5.1

// 访问和修改字段代码见4.1

// 获取类信息代码见6.1

    9.总结

    今天的内容涵盖了Java反射机制的基本概念和常用技术，包括获取Class对象、创建对象、访问字段、调用方法和获取类信息。反射机制是Java编程中非常强大的工具，务必熟练掌握。明天我们将深入学习Java的注解（Annotation）。

    提示：多动手编写代码，尝试使用反射机制解决实际问题，理解反射的工作原理和适用场景。

    祝你学习愉快！