反射机制_介绍_Class对象获取_动态操作_构造器_方法_属性JAVA211-212

本文深入讲解Java反射机制的基础知识及应用场景，包括Class对象的获取方式、动态操作类的构造器、方法和属性等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

来源：http://www.bjsxt.com/
一、S02E211_01反射机制_介绍_Class对象获取

动态语言

反射机制

Class类介绍
这里写图片描述

获取Class类的对象

package com.test.reflection;
/**
 * 测试各种类型(class,interface,enum,annotation,primitive type,void)对应的java.lang.Class对象的获取方式
 */
public class Demo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        String path = "com.test.bean.User";

        try {
            Class clazz = Class.forName(path);
            //对象是表示或封装一些数据。一个类被加载后，JVM会创建一个对应该类的Class对象，类的整个结构信息会放到对应的Class对象中。
            //这个Class对象就像一面镜子一样，通过这面镜子我们可以看到对应类的全部信息。
            System.out.println(clazz.hashCode());

            Class clazz2 = Class.forName(path);//一个类只对应一个Class对象
            System.out.println(clazz2.hashCode());

            Class strClazz = String.class;//类.class
            Class strClazz2 = path.getClass();//对象.getClass()
            System.out.println(strClazz==strClazz2);//true

            Class intClazz = int.class;//基本数据类型

            int[] arr01 = new int[10];
            int[][] arr02 = new int[30][3];
            int[] arr03 = new int[30];
            double[] arr04 = new double[10];
            System.out.println(arr01.getClass().hashCode());//同类型同维数的数组同对象，arr01和arr02同对象
            System.out.println(arr02.getClass().hashCode());
            System.out.println(arr03.getClass().hashCode());
            System.out.println(arr04.getClass().hashCode());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package com.test.bean;

public class User {
    private int id;
    private int age;
    private String uname;

    //javabean必须要有无参的构造方法！
    public User() {
    }
    public User(int id, int age, String uname) {
        super();
        this.id = id;
        this.age = age;
        this.uname = uname;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
}

控制台输出

二、S02E212_01反射机制_动态操作、构造器、方法、属性

反射机制的常见作用

package com.test.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 应用反射的API，获取类的信息(类的名字、属性、方法、构造器等)
 */
public class Demo01 {
    public static void main(String[] args) {
        String path = "com.test.bean.User";

        try {
            Class clazz = Class.forName(path);

            //获取类的名字
            System.out.println(clazz.getName());//获取包名+类名：com.test.bean.User
            System.out.println(clazz.getSimpleName());//获取类名：User

            //获取属性信息
            //Field[] fields = clazz.getFields();//只能获取public的field
            Field[] fields = clazz.getDeclaredFields();//获取所有的field
            Field f = clazz.getDeclaredField("uname");
            System.out.println(fields.length);
            for (Field temp : fields) {
                System.out.println("属性：" + temp);
            }
            //获取方法信息
            Method[] methods = clazz.getDeclaredMethods();
            Method m01 = clazz.getDeclaredMethod("getUname",null);
            //如果方法有参数，则必须传递参数类型对应的class对象
            Method m02 = clazz.getDeclaredMethod("setUname", String.class);
            for (Method temp : methods) {
                System.out.println("方法：" + temp);
            }
            //获取构造器信息
            Constructor[] constructors = clazz.getDeclaredConstructors();
            //Constructor c = clazz.getDeclaredConstructor(null);
            Constructor c = clazz.getConstructor(int.class,int.class,String.class);
            System.out.println("获取构造器：" + c);
            for (Constructor temp : constructors) {
                System.out.println("构造器：" + temp);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

控制台输出

com.test.bean.User
User
3
属性：private int com.test.bean.User.id
属性：private int com.test.bean.User.age
属性：private java.lang.String com.test.bean.User.uname
方法：public java.lang.String com.test.bean.User.getUname()
方法：public void com.test.bean.User.setUname(java.lang.String)
方法：public void com.test.bean.User.setId(int)
方法：public int com.test.bean.User.getAge()
方法：public void com.test.bean.User.setAge(int)
方法：public int com.test.bean.User.getId()
获取构造器：public com.test.bean.User(int,int,java.lang.String)
构造器：public com.test.bean.User()
构造器：public com.test.bean.User(int,int,java.lang.String)

package com.test.reflection;

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

import com.test.bean.User;
/**
 * 通过反射API动态地操作：构造器、方法、属性
 */
public class Demo02 {
    public static void main(String[] args) {
        String path = "com.test.bean.User";

        try {
            Class<User> clazz = (Class<User>) Class.forName(path);

            //通过反射API调用构造方法，构造对象
            User u1 = clazz.newInstance();//其实是调用了User的无参构造方法
            System.out.println(u1);

            Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
            User u2 = c.newInstance(1001,18,"测试2");
            System.out.println(u2.getUname());

            //通过反射API调用普通方法
            User u3 = clazz.newInstance();
            Method method = clazz.getDeclaredMethod("setUname", String.class);
            method.invoke(u3, "测试3");//u3.setUname("测试3");
            System.out.println(u3.getUname());

            //通过反射API操作属性
            User u4 = clazz.newInstance();
            Field f = clazz.getDeclaredField("uname");
            f.setAccessible(true);//这个属性不需要安全检查了，可以直接访问
            f.set(u4, "测试4");//通过反射直接写属性
            System.out.println(u4.getUname());
            System.out.println(f.get(u4));//通过反射直接读属性的值

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

控制台输出

com.test.bean.User@1db9742
测试2
测试3
测试4
测试4