反射的基本概念大家可以自行百度。我只贴出两段代码，里面有详细的注释，包含了了利用反射机制操作构造函数（有参和无参两种），属性，方法（静态和非静态）。其中心思想就是先获得Class。然后得到要操作的对象。再后调用各自的方法实现具体的操作。

Person类就是被操作的类，即通过反射机制得到该类的对象

[java] view plain copy

• package cn.itcast.refl;  
•   
• /**
• * 反射操作属性，无参构造，有参构造，普通方法
• *  
• * */  
• public class Person {  
•     // 属性  
•     private String name;  
•   
•     // 无参构造  
•     public Person() {  
•     }  
•   
•     // 有参构造  
•     public Person(String name) {  
•         this.name = name;  
•     }  
•   
•     // 普通方法(静态)  
•     public static void add(Integer a) {  
•         System.out.println(a*20);  
•     }  
•   
•     public String getName() {  
•         return name;  
•     }  
•     //普通方法（非静态）  
•     public void setName(String name) {  
•         this.name = name;  
•     }  
• }  
  

TestPerson类是测试Person类。反射操作属性，构造函数，方法的具体实现细节在此体现[java] view plain copy

• package cn.itcast.refl;  
•   
• import java.lang.reflect.Constructor;  
• import java.lang.reflect.Field;  
• import java.lang.reflect.Method;  
•   
• import org.junit.Test;  
•   
• public class TestPerson {  
•   
•     /**
•      * @param args
•      * @throws ClassNotFoundException
•      */  
•     public static void main(String[] args) throws ClassNotFoundException {  
•         // 通过对象的getClass()  
•         Person person = new Person();  
•         System.out.println(person.getClass());  
•         // 通过类的.class  
•         System.out.println(Person.class);  
•         // 通过Class类的forName()  
•         System.out.println(Class.forName("cn.itcast.refl.Person"));  
•   
•     }  
•   
•     // 不通过new的方式获取类的实例(操作无参的构造方法)  
•     @Test  
•     public void test() throws Exception {  
•         Person p = (Person) Class.forName("cn.itcast.refl.Person")  
•                 .newInstance();  
•         p.setName("haha");  
•   
•         System.out.println(p.getName());  
•     }  
•   
•     // 操作有参的构造方法  
•     @Test  
•     public void test2() throws Exception {  
•         Constructor constructor = Person.class.getConstructor(String.class);  
•         Person p = (Person) constructor.newInstance("wuwu");  
•         System.out.println(p.getName());  
•   
•     }  
•   
•     // 操作属性  
•     @Test  
•     public void test3() throws Exception {  
•         // 得到实例化对象  
•         Class p = Class.forName("cn.itcast.refl.Person");  
•         Person person = (Person) p.newInstance();  
•         // 得到属性  
•         Field field = p.getDeclaredField("name");  
•         // 使私有属性可获取  
•         field.setAccessible(true);  
•         // 属性赋值  
•         field.set(person, "dudu");  
•         // 获取  
•         System.out.println(field.get(person));  
•   
•     }  
•   
•     // 操作普通方法  
•     @Test  
•     public void test4() throws Exception {  
•         Class c = Person.class;  
•         Person p = (Person) c.newInstance();  
•   
•         // 得到方法  
•         Method m1 = c.getDeclaredMethod("setName", String.class);  
•         // 执行非静态方法，并传值  
•         m1.invoke(p, "lala");  
•         System.out.println(p.getName());  
•         // 执行静态方法(与非静态区别就是invole方法的第一个参数是null。)  
•         Method m2 = c.getDeclaredMethod("add", Integer.class);  
•         m2.invoke(null, 3);  
•   
•     }  
• }  
  

最终的运行结果如下

【转载】原文地址：https://blog.csdn.net/weixin_42331540/article/details/80596933