Java反射机制基础知识之Class类和反射方法调用构造函数

一般通过构造方法创建对象时，A a = new B()，会在编译器确定对象的类型；但是有些时候，只有在程序运行起来的时候，才能确定对象的类型Class.forName("?").newInstance(),这种时候就要用到反射机制。

了解一下：

编译期：把源码交给编译器编译成计算机可以执行的文件的过程。

运行期：把编译后的文件交给计算机执行，知道程序运行结束。

java反射机制：在运行状态中，对于任意一个类，都能够知道这个类地所有属性和方法；对于任意一个对象，都能够调用他的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能成为java的反射机制。一般在主流的ROM框架的实现中，运用java反射机制可以读取任意一个JavaBean的的所有属性，或者可以给这些属性赋值。

Class类

在Java中，Class类是反射的核心类之一，它在反射中起着重要的作用。Class类提供了许多方法来获取和操作类的信息，包括类的构造函数、字段、方法等。

通过Class类的这些方法，在运行时动态地获取和操作类的信息，包括类的构造函数、字段、方法等。这使得能够在运行时根据需要加载和使用不同的类，并且可以通过反射来调用类的方法、访问类的字段等。

获取class的Class实例的方法：

1. 通过类名访问Class
2. 通过实例访问getClass()
3. 通过Calss类的静态方法forName(类名)

public class Demo1 {

	public static void main(String[] args) throws ClassNotFoundException {
		//方式一：通过类名访问Class
		Class stringCls1 = String.class;
		
		//方式二：通过实例访问getClass()
		String s = "";
		Class stringCls2 = s.getClass();
		
		//方式三：通过Calss类的静态方法forName(类名)
		Class stringCls3 = Class.forName("java.lang.String");
		
		//相同的calss对象
		System.out.println(stringCls1.hashCode());
		System.out.println(stringCls2.hashCode());
		System.out.println(stringCls3.hashCode());
	}
}

JVM在第一次读取到一种class类型时，就将其加载至内存。每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来，在后续使用该实例时，使用的是同一个。

通过class实例可以获取的基本信息

//获取Class类型信息
public static void printClassInfo(Class cls) {
		
//类名
    System.out.println("类(接口)的名称："+cls.getSimpleName());
    System.out.println("完全限定名："+cls.getName());
	System.out.println("类(接口)的类型名称："+cls.getTypeName());
		
	//父类
	Class superCls = cls.getSuperclass();
	System.out.println("类的父类:"+superCls.toString());
		
	//实现的接口
	Class[] interfaceCls = cls.getInterfaces();
	System.out.println("当前实现的接口：");
	for(Class icls : interfaceCls) {
		System.out.println(icls);
	}
		
	//package包
	Package pck = cls.getPackage();
	if(pck != null) {
		System.out.println("类所在包的名称："+pck.getName());
	}else {
		System.out.println("不存在");
	}
		
	//判断类型
	System.out.println("是否为接口"+cls.isInterface());
	System.out.println("是否为数组"+cls.isArray());
	System.out.println("是否为枚举"+cls.isEnum());
	}

}
class Person{
	//....
}

下面是Class类在反射中的一些常用方法和作用：

1. forName(String className)：通过类的全限定名加载类。这个方法可以在运行时动态加载类，可以根据类名字符串加载不同的类。
2. newInstance()：创建类的实例。通过该方法可以动态地创建类的对象。
3. getMethod(String name, Class<?>... parameterTypes)：获取类的方法。可以通过方法名和参数类型获取类的具体方法。
4. getConstructor(Class<?>... parameterTypes)：获取类的构造函数。可以通过参数类型获取类的具体构造函数。
5. getField(String name)：获取类的字段。可以通过字段名获取类的具体字段。
6. getDeclaredMethods()：获取类的所有方法，包括私有方法。可以获取类中声明的所有方法，包括公共、保护、默认和私有方法。
7. getDeclaredFields()：获取类的所有字段，包括私有字段。可以获取类中声明的所有字段，包括公共、保护、默认和私有字段。
8. getModifiers()：获取类的修饰符。可以获取类的修饰符，如`public`、`private`、`abstract`等。

动态加载机制

JVM在执行Java程序时，并不会一次性将所有使用到的类全部加载到内存中，而是在第一次需要使用类时才进行加载。使用反射的方法，可以在运行时加载类，通过newInstance()的方法创建实例

例：

在本地文件中写一个txt文档，包含所需的类名

然后在java程序中创建这个类

class Order{
	private String orderNo;
	private LocalDateTime creationTime;
	
	public Order() {
		this.orderNo = UUID.randomUUID().toString();
		this.creationTime = LocalDateTime.now();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public String getOrderNo() {
		return orderNo;
	}

	public void setOrderNo(String orderNo) {
		this.orderNo = orderNo;
	}

	public LocalDateTime getCreationTime() {
		return creationTime;
	}

	public void setCreationTime(LocalDateTime creationTime) {
		this.creationTime = creationTime;
	}

	@Override
	public String toString() {
		return "Order [orderNo=" + orderNo + ", creationTime=" + creationTime + "]";
	}

在使用时，通过文件获取该类的类名，并得到Class的对象，然后创建实例

public class Demo3 {

	public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {

		//读取该类的名称
		String className = Files.readAllLines(Paths.get("E:\\猿究院\\20230711\\refl.txt")).get(0); 
		
		//得到该类的Calss对象
		Class cls = Class.forName(className);
		
		//创建三个对象
		Object obj1 = cls.newInstance();
		Object obj2 = cls.newInstance();
		Object obj3 = cls.newInstance();
		
		System.out.println(obj1);
		System.out.println(obj2);
		System.out.println(obj3);
	}

反射方法调用构造函数

使用Class.newInsatnce()这个方法只能狗调用无参的构造方法来创建对象，但是我们在使用过程中，不可能所有都使用无参的构造方法，那么我们可以使用反射的方法来调用有参的构造函数以创建对象

//反射方法调用构造函数
public class Demo4 {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		Class cls = Example.class;
		
		//调用无参的构造方法创建Example类型的对象
		Example ex1 = (Example) cls.newInstance();
		System.out.println(ex1);
		
		//获取所有的构造方法
		System.out.println("所有的构造方法");
		Constructor[] constructArray = cls.getConstructors();
		for(Constructor con : constructArray) {
			System.out.println(con);
		}
		
		System.out.println("===============================");
		//调用有参构造方法创建Example类型的对象
		//1.获取指定的构造方法
		//无参构造
		//Constructor constructor = cls.getConstructor();
		
		//有一个参数的构造方法
		//Constructor constructor = cls.getConstructor(int.class);
		
		//有两个参数的构造方法
		Constructor constructor = cls.getConstructor(int.class,double.class);
		System.out.println(constructor);
		
		//2.执行构造方法，创建Example类型的对象
		Example ex2 = (Example) constructor.newInstance(1024,3.14);
		System.out.println(ex2);
	}

}

class Example{
	
	public Example(){
		System.out.println("无参的构造方法");
	}
	
    public Example(int a) {
    	System.out.printf("有参的构造方法a=%d\n",a);
    }
    
    public Example(int a,double b) {
    	System.out.printf("有参的构造方法a=%d,b=%f\n",a,b);
    }
}

在上述方法中，getConstructors()用来获取所有构造方法，但是它获取的是所有的public公开构造方法，当方法私有或者受保护时，并不能使用该方法来获取。

getDeclaredConstructors()  -->  获取所有的构造方法(包括私有和者受保护的)；

//获取所有定义地构造方法
Constructor[] constructArray = cls.getDeclaredConstructors();
for(Constructor con : constructArray) {
	System.out.println(con);
}
		
//获取一个私有地构造方法·
Constructor privateConstruct = cls.getDeclaredConstructor(String.class);
		
//调用私有的构造方法
privateConstruct.setAccessible(true);
Example ex = (Example) privateConstruct.newInstance("just");
System.out.println(ex);


class Example{
	
	private Example(String s) {
		System.out.printf("私有的有参构造s = %s\n",s);
	}
	
	protected Example(double b) {
		System.out.printf("受保护的有参构造 b= %f\n",b);
	}
	
	public Example(){
		System.out.println("无参的构造方法");
	}
	
    public Example(int a) {
    	System.out.printf("有参的构造方法a=%d\n",a);
    }
    
    public Example(int a,double b) {
    	System.out.printf("有参的构造方法a=%d,b=%f\n",a,b);
    }

通过设置privateConstruct.setAccessible(true)可以调用一个私有的构造方法，对于该方法来说，它破坏了java的封装性但是同时也为我们提供了更多操作的可能性。

笔记补充：