Java反射机制初探：了解Class、Method、Field和Constructor

Java反射机制初探：了解Class、Method、Field和Constructor

引言：

在Java编程中，反射机制是一个强大且常用的工具。它允许我们在运行时动态地获取类的相关信息，并且能够通过类对象实例化对象、调用方法和操作属性。本文将介绍如何使用Java反射机制来获得类的相关信息，并通过一个示例详细说明其使用方法。

一、Java反射机制简介

1.1 什么是反射机制？

Java反射机制是指在运行时动态地获取类的相关信息以及操作类的属性、方法和构造函数等。传统的编程方式在编译期间需要确定类的具体信息，而反射机制则将这种操作推迟到运行时。

1.2 反射机制的应用场景

反射机制在以下场景中得到广泛应用：

动态加载类：可以在运行时根据配置文件或用户输入动态地加载不同的类。
运行时分析类的属性和方法：通过反射可以获取类的字段和方法，并对其进行操作。
动态代理：反射机制可以用于生成动态代理对象。
框架开发：很多框架都基于反射机制，例如Spring、Hibernate等。

二、案例详解

案例代码：

package co;

import co.goho.uanyu.pojo.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class test{
    public static void main(String[] args) {
        //获得Student类的class对象
        try {
            Class c = Class.forName("co.goho.uanyu.pojo.Student");
            //获得student类所有的公开方法，返回一个方法数组,只能获取公有的
            Method[] methods = c.getMethods();
            for (Method method : methods) {
                System.out.println(method.getName());
            }

            //获取构造方法,只能获取公有的
            Constructor[] constructors = c.getConstructors();
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }

            //获取student中的成员变量,只能获取公有的
            Field[] fields = c.getFields();
            for (Field field : fields) {
                System.out.println(field);
            }

            //获取student中的成员变量,能获取私有
            Field[] files1 = c.getDeclaredFields();
            for (Field field : files1) {
                System.out.println(field);
            }

            //根据方法名称和参数类型，找到特定的方法
            Constructor noArgsCOnst = c.getConstructor(null);
            System.out.println(noArgsCOnst.getParameterCount());

//            使用class对象获得构造方法，并且使用构造方法创建对象
            Constructor ctt0=c.getConstructor(null);
            Object o0=ctt0.newInstance();
            System.out.println(o0);

            //调用有参构造
            Constructor ctt2=c.getConstructor(int.class,String.class,float.class);
            Object o1=ctt2.newInstance(1,"张三",3.8f);
            System.out.println(o1);


            //o0对象只有初始化属性，显示 3,"李四" 200
            //找到对象的三个set
            Method a=c.getMethod("setId",int.class);
            Method b=c.getMethod("setName",String.class);
            Method d=c.getMethod("setBalance",float.class);

            a.invoke(o0,3);
            b.invoke(o0,"李四");
            d.invoke(o0,200f);
            System.out.println(o0);

        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }

        Map<String,Object>map=new HashMap<String,Object>();
        map.put("id",4);
        map.put("name","王五");
        map.put("balance",3.89f);

        Student s= (Student) getBean(Student.class,map);
        System.out.println(s);
    }

    private static Object getBean(Class<?> studentClass, Map<String, Object> map) {
        try {
            // 创建对象
            Object studentObj = studentClass.newInstance();

            // 获取属性列表
            Field[] fields = studentClass.getDeclaredFields();

            // 遍历属性列表
            for (Field field : fields) {
                // 设置属性可访问
                field.setAccessible(true);

                // 获取属性名称
                String fieldName = field.getName();

                // 判断属性是否在Map中存在
                if (map.containsKey(fieldName)) {
                    // 获取属性值
                    Object value = map.get(fieldName);

                    // 设置属性值
                    field.set(studentObj, value);
                }
            }
            return studentObj;
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

运行结果

上述代码示例中，我们以一个Student类为例，通过反射机制获取该类的相关信息并进行操作。以下是代码示例的详细解释：

2.1 获取Class对象

首先，我们使用Class.forName方法获取Student类的Class对象，这个对象包含了类的所有信息。

2.2 获取公开方法、构造函数和成员变量

接下来，我们使用getMethods、getConstructors、getFields和getDeclaredFields等方法获取Student类中的公开方法、构造函数和成员变量。

getMethods：获取公开方法（仅限公有方法）

getConstructors：获取构造函数（仅限公有构造函数）

getFields：获取公开成员变量（仅限公有成员变量）

getDeclaredFields：获取所有成员变量（包括私有）

2.3 使用反射创建对象和调用方法

我们通过Constructor的newInstance方法来创建对象，并使用Method的invoke方法来调用方法，包括公开和私有方法。

2.4 动态设置属性值

我们通过Field的set方法动态设置对象的属性值，这里通过一个辅助方法getBean实现了将Map中的值设置到Student对象中的功能。

三、总结

本文介绍了Java反射机制的基本概念和使用方法，并通过一个具体的案例详细讲解了如何通过反射来获取类的相关信息、创建对象、调用方法和设置属性值。反射机制在一些特定的场景下非常有用，但也需要注意它的性能开销以及安全性问题。
方法动态设置对象的属性值，这里通过一个辅助方法getBean实现了将Map中的值设置到Student对象中的功能。