目录
[七、使用 Java 反射机制获取和调用类的构造方法，访问私有构造方法并创建对象](#七、使用 Java 反射机制获取和调用类的构造方法，访问私有构造方法并创建对象)
一、什么是反射？
反射 (Reflection)是一种 Java 程序运行期间 的动态 技术，可以在运行时 (runtime)检査、修改其自身结构或行为。通过反射，程序可以访问、检测和修改它自己的类、对象、方法、属性等成员
二、反射的用途
- 动态加载类 :程序可以在运行时动态地加载类库中的类；
- 动态创建对象 :反射可以基于类的信息，程序可以在运行时，动态创建对象实例;
- 调用方法 :反射可以根据方法名称，程序可以在运行时，动态地调用对象的方法(即使方法在编写程序时还没有定义)
- 访问成员变量 :反射可以根据成员变量名称，程序可以在运行时，访问和修改成员变量(反射可以访问私有成员变量)
- 运行时类型信息 :反射允许程序在运行时，查询对象的类型信息，这对于编写通用的代码和库非常有用;
Spring 框架使用反射来自动装配组件，实现依赖注入;
MyBatis 框架使用反射来创建resultType 对象，封装数据查询结果;
三、获取Class对象
反射的第一步是获取 Class 对象。Class 对象表示某个类的元数据，可以通过以下几种方式获取：
java
//获取Class类型信息
public class Text02 {
public static void main(String[] args) throws ClassNotFoundException {
//方式1:通过类名
Class stringClass1 = String.class;
//方式2：通过Class类的forName()方法
Class stringClass2 = Class.forName("java.lang.String");
//方式3：通过对象调用getClass()方法
Class stringClass3 = "".getClass();
System.out.println(stringClass1.hashCode());//1604839423
System.out.println(stringClass2.hashCode());//1604839423
System.out.println(stringClass3.hashCode());//1604839423
}
}四、Class类型的对象使用场景1
将一个 JSON 字符串解析为 Java 对象，并输出该对象的字段值。
java
//Class类型的对象使用场景1
public class Text03 {
public static void main(String[] args) {
String json= "{\"name\":\"长安荔枝\",\"favCount\":234}";
//方法定义
Document doc=JSON.parseObject(json,Document.class);
System.out.println(doc.getName());
System.out.println(doc.getFavCount());
}
}使用 JSON.parseObject 方法将 JSON 字符串解析为 Document 类的对象。在解析过程中，JSON 字符串中的数据会自动映射到 Document 类的对应字段中。
五、Class类型的对象使用场景2
通过 Class 对象在运行时获取一个类的相关信息，包括类名、包名、成员变量（字段）、成员方法等。
java
//Class类型的对象使用场景2
//获取丰富的类型内容
public class Text04 {
public static void main(String[] args) throws ClassNotFoundException {
Class clz = Class.forName("java.util.HashMap");
//获取类名
System.out.println("完全限定名："+clz.getName());
System.out.println("简单的类名："+clz.getSimpleName());
//获取包名
System.out.println("package"+clz.getPackage().getName());
System.out.println();
//获取成员变量
Field[] fieldArray =clz.getDeclaredFields();
System.out.println("成员变量(字段)");
for(Field field:fieldArray) {
System.out.println(field);
}
System.out.println();
//获取成员方法
Method[] methodArray = clz.getDeclaredMethods();
System.out.println("成员方法");
for(Method method:methodArray) {
System.out.println(method);
}
}
}clz.getName()返回类的完全限定名，包括包名，例如"java.util.HashMap"。clz.getSimpleName()返回类的简单名称，不包括包名，例如"HashMap"。clz.getPackage().getName()返回类所属的包名，例如"java.util"。clz.getDeclaredFields()返回一个Field数组，包含了类声明的所有字段（包括私有字段）。clz.getDeclaredMethods()返回一个Method数组，包含了类声明的所有方法（包括私有方法）。
六、通过反射创建对象
方式一：通过 Class 对象直接调用 newInstance() 方法
方式二：通过获取构造方法（Constructor）来创建对象。
java
//通过反射的方式，创建对象
public class Text05 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
Class clz = Class.forName("com.apesource.demo01.Document");
//方式1：直接通过Class对象，调用newInstance()方法
Object objx = clz.newInstance();//相当于在执行无参构造方法
//方式2：通过构造器(构造方法)
//无参构造方法
Constructor constructor1 = clz.getDeclaredConstructor();//获取无参构造方法
System.out.println(constructor1);
Object obj1 = constructor1.newInstance();//执行构造器(构造方法),创建对象
//有参构造方法
Constructor constructor2 = clz.getDeclaredConstructor(String.class);//获取有参构造方法
System.out.println(constructor2);
Object obj2 = constructor2.newInstance("两京十五日");
Constructor constructor3 = clz.getDeclaredConstructor(int.class);//获取有参构造方法
System.out.println(constructor3);
Object obj3 = constructor3.newInstance(34);
Constructor constructor4 = clz.getDeclaredConstructor(String.class,int.class);//获取有参构造方法
System.out.println(constructor4);
Object obj4 = constructor4.newInstance("风起陇西",64);
System.out.println(objx);
System.out.println(obj1);
System.out.println(obj2);
System.out.println(obj3);
System.out.println(obj4);
}newInstance()方法是Class对象提供的一个方法，它调用类的无参构造方法来创建类的实例。- 注意 ：这个方法在 Java 9 以后已经被弃用，推荐使用
Constructor对象来创建实例。 - 通过
getDeclaredConstructor()方法获取Document类的无参构造方法，然后调用newInstance()方法创建实例。 - 注意 ：如果类中没有无参构造方法，调用
getDeclaredConstructor()会抛出NoSuchMethodException。 - 通过
getDeclaredConstructor(String.class)获取带有一个String参数的构造方法，并传入"两京十五日"作为参数来创建对象。 - 通过
getDeclaredConstructor(int.class)获取带有一个int参数的构造方法，并传入34作为参数来创建对象。
七、使用 Java 反射机制获取和调用类的构造方法，访问私有构造方法并创建对象
java
public class Text06 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class clz = Class.forName("com.apesource.demo01.Document");
//获取一组构造器
Constructor[] constructorArray1 = clz.getConstructors();//public
Constructor[] constructorArray2 = clz.getDeclaredConstructors();//public、private
//获取指定构造器
Constructor constructor1 = clz.getConstructor();
Constructor constructor2 = clz.getDeclaredConstructor(String.class);
System.out.println(constructor1);
System.out.println(constructor2);
//调用私有构造器，必须设置它的访问全限
constructor2.setAccessible(true);
//调用构造器，创建对象
Object obj = constructor2.newInstance("长安三万里");
System.out.println(obj);
}
}getConstructors()方法返回一个包含所有公共（public）构造方法的数组。如果类中没有public构造方法，则返回空数组。getDeclaredConstructors()方法返回一个包含所有声明的构造方法的数组（包括私有的、受保护的和默认访问级别的构造方法）。getConstructor()方法用于获取类的无参构造方法（必须是public的）。如果没有无参构造方法或者不是public，则抛出NoSuchMethodException。getDeclaredConstructor(Class<?>... parameterTypes)方法用于获取指定参数类型的构造方法。这里通过传入String.class参数获取一个带有String参数的构造方法。这个构造方法可以是任何访问级别（public、private、protected、默认）。setAccessible(true)用于绕过 Java 访问控制机制，使私有构造方法也可以被调用。如果不设置Accessible为true，那么调用私有构造方法时会抛出IllegalAccessException。newInstance(Object... initargs)方法使用指定的构造方法创建对象。这里调用了带有String参数的构造方法，并传入"长安三万里"作为参数。
八、通过反射，访问并使用成员方法
java
public class Text08 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
//硬编码的方式
// Document doc1 = new Document();
// doc1.setName("海底两万里");
// doc1.setFavCount(10025);
//反射的方式
Class clz = Class.forName("com.apesource.demo01.Document");//获取类型信息
Object doc1 = clz.newInstance();//创建对象
//获取指定名称和参数类型的方法
Method setNameMethod = clz.getMethod("setName", String.class);
Method setFavCountMethod = clz.getMethod("setFavCount", int.class);
//执行方法
//doc1.setName("海底两万里");
setNameMethod.invoke(doc1, "海底两万里");
//doc1.setFavCount(10025);
setFavCountMethod.invoke(doc1, 10025);
System.out.println(doc1);
}
}getMethod(String name, Class<?>... parameterTypes)方法用于获取类的某个public方法。方法名称和参数类型必须匹配才能成功获取方法。invoke(Object obj, Object... args)方法用于调用指定的实例方法。setNameMethod.invoke(doc1, "海底两万里");等同于doc1.setName("海底两万里");。setFavCountMethod.invoke(doc1, 10025);等同于doc1.setFavCount(10025);。
九、通过反射，调用静态方法以及处理可变参数
java
public class Text09_01 {
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
//硬编码的方式
//调用静态方法
// Document.dosth();
String ret1 = String.format("HashMap的默认初始容量是%d,加载因子是%.2f", 16,0.75f);
System.out.println(ret1);
//反射的方式
// Class clz = Class.forName("com.apesource.demo01.Document");
// Method dosthMethod = clz.getMethod("dosth");
// dosthMethod.invoke(null);
Class clz = String.class;
Method formatMethod = clz.getMethod("format", String.class,Object[].class);
String ret2 = formatMethod.invoke(null, "HashMap的默认初始容量是%d,加载因子是%.2f",new Object[] {16,0.75f}).toString();
System.out.println(ret2);
}
}- 这是直接调用静态方法的传统方式。假设
Document类有一个名为dosth()的静态方法，可以直接使用类名调用。 String.format是一个静态方法，用于格式化字符串，类似于printf的格式化规则- 获取
String类的Class对象 ：使用Class clz = String.class;。 - 获取
String类的Class对象 ：使用Class clz = String.class;。 - 调用静态方法 ：使用
invoke(null, "HashMap的默认初始容量是%d,加载因子是%.2f", new Object[] {16, 0.75f})调用静态方法，因为format是静态方法，所以第一个参数是null。 - 注意
invoke方法中，Object[]参数必须以数组形式传递，所以用了new Object[] {16, 0.75f}。
十、反射的性能问题
反射虽然功能强大，但由于是在运行时动态操作类，因此性能相对较低。此外，反射也会破
坏封装性，使用时要谨慎。
十一、反射的安全性
使用反射时需要注意安全问题，因为它可以绕过 Java 的访问控制机制。例如，可以访问私有
字段或方法，因此在开发中使用反射要特别小心。
十二、反射的常见场景
- 框架开发：如 Spring 中的依赖注入、Hibernate 中的 ORM 等。
- 调试工具：如 Java 的调试器、分析工具等。
- 动态代理：在 Java 中，动态代理依赖于反射。