Java反射基础知识

最新推荐文章于 2024-07-10 21:37:49 发布

TTODS.

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量157

点赞数

文章标签： java 反射 class 类 spring

本文链接：https://blog.csdn.net/qq_44525150/article/details/107429131

版权

java基础学习笔记专栏收录该内容

22 篇文章 2 订阅

订阅专栏

不登高山，不知天之高也；不临深溪，不知地之厚也。

| @Author：TTODS

学习反射必须知道的几个类

Class

Class类的实例表示运行的Java程序中类和接口，枚举类型是一种类，注解类型一种属于接口。

怎么获得Class类的对象？

下面使用了三种方法来获取在包bean下的User类的Class对象。

@Test
public  void testGetClassObj() {
	try {
		/**Class对象的获取方法*/
		/** 方法一 通过类的全限定名获取 */
		Class<?> clazz = Class.forName("bean.User");
		System.out.println(clazz);
		
		/** 方法二 通过类的实例获取 */
		User user = new User();
		Class<?> clazz1 = user.getClass();
		System.out.println(clazz1);
		
		/** 方法三 通过类名.class获取 */
		Class<?> clazz2 = User.class;
		System.out.println(clazz2);
	} catch (ClassNotFoundException e) {
		// TODO: handle exception
		System.out.println("类未找到");
	}

}

class bean.User
class bean.User
class bean.User

Class类的基本知识点

每一个类只对应一个Class对象。
下面代码使用了三种不同的方法获取bean.User的Class实例，且第三种方法使用了不同实例获取Class实例，所有这些获取到的对象均是同一个对象。

@Test
public  void testClassObj() {
	try {
		/** 通过三种不同方法来获得User类的Class的实例 */
		Class<?> clazz = User.class;
		Class<?> clazz1 = Class.forName("bean.User");
		/** 通过不同实例获取User类的Class的实例 */
		User u = new User();
		User u1 = new User();
		Class<?> clazz2 = u.getClass();
		Class<?> clazz3 = u1.getClass();
		System.out.println(clazz==clazz1);
		System.out.println(clazz1==clazz2);
		System.out.println(clazz2==clazz3);
	} catch (ClassNotFoundException e) {
		// TODO: handle exception
		System.out.println("类未找到");
	}

}

相同类型且维度相同的数组将作为同一个类共享一个Class实例，与数组的长度无关。

@Test
/**
 *  数组的Class对象只与数组中存放的数据类型和数组的维度有关，与数组的长度无关
 */
public void testArrayClass() {
	/** 两个一维int数组*/
	int[] nums01 = new int[10]; 
	int[] nums02 = new int[20];
	/** 两个二维维int数组*/
	int [][] nums03  =new int[10][10];
	int [][] nums04 = new int[1][2];
	/** 一个一维char数组 */
	char [] chars01 = new char[10];
	/** 一个二维char数组 */
	char [][] chars02 = new char[2][5];
	/** 获取Class对象*/
	Class<?> nums01Class  =nums01.getClass();
	Class<?> nums02Class  =nums02.getClass();
	Class<?> nums03Class  =nums03.getClass();
	Class<?> nums04Class  =nums04.getClass();
	Class<?> chars01Class = chars01.getClass();
	Class<?> chars02Class = chars02.getClass();
	/** 比较*/
	System.out.println("nums01Class(一维，10)==nums02Class(一维，20): "+(nums01Class==nums02Class));
	System.out.println("nums01Class(一维，10)==nums03Class(二维，10x10): "+(nums01Class==nums03Class));
	System.out.println("nums02Class(一维，20)==nums03Class(二维，10x10): "+(nums02Class==nums03Class));
	System.out.println("nums03Class(二维，10x10)==nums04Class(二维，1x2): "+(nums03Class==nums04Class));
	System.out.println("nums01Class(一维，10)==chars01Class(一维，10): "+(nums01Class==chars01Class));
	System.out.println("chars01Class(一维，10)==chars02Class(二维，2x5): "+(chars01Class==chars02Class));
}
}

nums01Class(一维，10)==nums02Class(一维，20): true
nums01Class(一维，10)==nums03Class(二维，10x10): false
nums02Class(一维，20)==nums03Class(二维，10x10): false
nums03Class(二维，10x10)==nums04Class(二维，1x2): true
nums01Class(一维，10)==chars01Class(一维，10): false
chars01Class(一维，10)==chars02Class(二维，2x5): false

基本数据类型和关键字void都有一个Class。基本数据类型的Class对象并不是其包装类的Class对象

@Test
public void testPrimitiveClass() {
	//byte
	Class<?> byteClass = byte.class;
	System.out.println(byteClass);
	//short
	Class<?> shortClass = short.class;
	System.out.println(shortClass);
	//int
	Class<?> intClass = int.class;
	System.out.println(intClass);
	//long
	Class<?> longClass = long.class;
	System.out.println(longClass);
	
	//char 
	Class<?> charClass=char.class;
	System.out.println(charClass);
	
	//boolean
	Class<?> booleanClass = boolean.class;
	System.out.println(booleanClass);
	
	//float
	Class<?> floatClass = float.class;
	System.out.println(floatClass);
	
	//double
	Class<?> doubleClass = double.class;
	System.out.println(doubleClass);

	//void
	Class<?> voidClass = void.class;
	System.out.println(voidClass);
	
	//Integer 
	Class<?> IntegerClass = Integer.class;
	System.out.println(IntegerClass);
	/** 基本数据类型的Class对象 并不等于其包装类的Class对象*/
	System.out.println("Integer.Class==intClass: "+(IntegerClass==intClass));

}

byte
short
int
long
char
boolean
float
double
void
class java.lang.Integer
Integer.Class==intClass: false

Class类没有公有的构造器，当一个类被JVM加载时，这个类对应的Class实例就会自动被创建。
源码：

  /*
   * Private constructor. Only the Java Virtual Machine creates Class objects.
   * This constructor is not used and prevents the default constructor being
   * generated.
   */
  private Class(ClassLoader loader) {
      // Initialize final field for classLoader.  The initialization value of non-null
      // prevents future JIT optimizations from assuming this final field is null.
      classLoader = loader;
  }

Field

Field 在数据库中是字段的意思，对应到类中就是属性的意思，Field提供有关类或接口的单个字段的信息和动态访问。反射的字段可以是类（静态）字段或实例字段。

获取Field对象

为了测试，我为bean.User类定义了下面的属性

/** 不同访问权限的属性 */
//私有
private int id;
private String name;
private int age;
//受保护
protected String protectedField;
//公有
public String publicField;
//默认（包）
String defaultField;

我们可以使用Class对象的getFields()和getDeclaredFields()等方法来获取该对象所表示类所含的属性对应的Field对象的列表。getFields()方法只能获取到公有访问权限的属性,getDeclaredFields()方法可以获取所有已声明的属性，但是不能获取继承的属性。同样，我们也可以使用getField(String fieldName)和getDeclaredField(String fieldName)的方法来获取知道属性所对应的Field对象

@Test
public void testGetField() {
	User user = new User();
	Class<User> clazz = (Class<User>) user.getClass();
	/** 获取公有属性(包括继承的公有属性) */
	Field[] fields = clazz.getFields();
	for (int i = 0; i < fields.length; i++) {
		System.out.println("属性:" + fields[i]);
	}
	System.out.println("-------------分隔线------------------");
	/** 获取所有声明的属性 但不包括继承属性 */
	Field[] fields1 = clazz.getDeclaredFields();
	for (int i = 0; i < fields1.length; i++) {
		System.out.println("属性:" + fields1[i]);
	}
	System.out.println("-------------分隔线------------------");
	/** 获取指定的属性 */
	try {
		/** id 是一个私有的属性 getDeclaredField(String name) 的方法可以获取 */
		Field idField = clazz.getDeclaredField("id");
		System.out.println(idField);
		/** getField方法不能获取到私有属性 */
		idField = clazz.getField("id");
		System.out.println(idField);
	} catch (NoSuchFieldException e) {
		System.out.println("找不到对应方法:" + e.getMessage());
	} catch (Exception e) {
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
}

属性:public java.lang.String bean.User.publicField
-------------分隔线------------------
属性:private int bean.User.id
属性:private java.lang.String bean.User.name
属性:private int bean.User.age
属性:protected java.lang.String bean.User.protectedField
属性:public java.lang.String bean.User.publicField
属性:java.lang.String bean.User.defaultField
-------------分隔线------------------
private int bean.User.id
找不到对应方法:id

Field的set与get方法

我们可以使用Field类的get(Object obj)和set(Object obj,Object value)方法来获取和修改指定对象的对应属性的值。
对于私有属性和其他非公有属性要先setAccessible(true),表示在此反射对象使用时不进行访问权限的检查，否则可能修改非公有属性(视访问权限而定)。
对于static属性(类属性)，get和set方法的第一个参数将会被忽略，可以设为null.

@Test
public void testFieldSetAndGet() throws Exception{
	Class<User> clazz = User.class;
	User user = new User();
	/** 获取并修改 对象public 访问权限属性 */
	Field publicField = clazz.getField("publicField");
	System.out.println(publicField);
	System.out.println("set()之前: "+publicField.get(user));
	publicField.set(user,"It is not a secret of mine");
	System.out.println("set()之后: "+publicField.get(user));
	System.out.println();
	
	/** 获取并修改 对象的其他访问权限的属性 */
	Field privateField = clazz.getDeclaredField("id");
	System.out.println(privateField);
	privateField.setAccessible(true);//设置在此反射对象使用时不进行访问权限的检查
	System.out.println("set()之前: "+privateField.get(user));
	privateField.set(user,9);
	System.out.println("set()之后: "+privateField.get(user));
	System.out.println();
	
	/** 获取static Field 传入的参数将被忽略(set同理) */
	System.out.println(Math.class.getField("PI").get(null));
	System.out.println(Math.class.getField("PI").get(user));// <- 即使随便给一个实例也不会报错
}

public java.lang.String bean.User.publicField
set()之前: null
set()之后: It is not a secret of mine

private int bean.User.id
set()之前: 0
set()之后: 9

3.141592653589793
3.141592653589793

Constructor

Constructor提供了一个类的单个构造函数的信息和访问。

获取Constructor对象

为了测试我们先给bean.User类创建了三个构造器

//公有有参构造器
public User(int id, String name, int age) {
	super();
	this.id = id;
	this.name = name;
	this.age = age;
}
//公有无参构造器
public User() {
	this.name = "unnamed";
}
//私有有参构造器
@SuppressWarnings("all")
private User(int id) {
	this.id = id;
	this.name = "unnamed";
}

与上面获取Field对象的方法类似，我们可以使用Class类的getConstructors()方法和getDeclaredConstructors()方法来获取对应类的构造器列表。使用getConnstructor(Class<?>...parameterTypes)方法获取指定参数列表的构造器;

@Test
public void testGetConstructor() throws Exception{
	User user = new User();
	Class<User> clazz = (Class<User>) user.getClass();
	/** 获取公有构造器 */
	Constructor<?>[] constructors = clazz.getConstructors();
	for(int i=0;i<constructors.length;i++) {
		System.out.println(constructors[i]);
	}
	System.out.println("-------------分隔线------------------");
	/** 获取所有声明的构造器 */
	Constructor<?>[] constructors1 = clazz.getDeclaredConstructors();
	for(int i=0;i<constructors1.length;i++) {
		System.out.println(constructors1[i]);
	}
	System.out.println("-------------分隔线------------------");
	/** 通过指定参数类别来获取构造器 */
	Constructor<User> constructor = clazz.getDeclaredConstructor(int.class);
	System.out.println(constructor);
}

public bean.User()
public bean.User(int,java.lang.String,int)
-------------分隔线------------------
private bean.User(int)
public bean.User()
public bean.User(int,java.lang.String,int)
-------------分隔线------------------
private bean.User(int)

使用反射创建对象

我们可以使用Class类的对象的newInstance()方法来获得一个该Class对象表示的类的实例，前提是该Class对象表示的类有可访问的的无参构造器。
我们也可以调用该类的Constructor的newInstance()方法来创建该类的实例。

@Test
public void testNewInstance() {
	User user = new User();
	Class<User> clazz = (Class<User>) user.getClass();
	
		/** 使用 newInstance方法 获得新的实例 使用此方法 Class对象所代表的类一定要有可访问无参构造方法*/
		try {
			User u = clazz.newInstance();
			System.out.println("clazz.newInstance() => "+u);
		} catch (InstantiationException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		
		/** 使用 其他的公有构造器 获得新的实例 */
		try {
			Constructor<User> publicConstructor = clazz.getConstructor(int.class,String.class,int.class);
			User u = publicConstructor.newInstance(1,"Bob",6);
			System.out.println("publicConstructor.newInstance() => " +u);
		} catch (NoSuchMethodException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ReflectiveOperationException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		/** 使用 非公有构造器 获得新的实例 */
		try {
			/** 使用getDeclareConstructor方法才能获取到非公有访问权限的构造器  */
			Constructor<User> privateConstructor = clazz.getDeclaredConstructor(int.class);
			/** 使用setAccessible(true)方法可以将不能访问的构造器设为可访问 */
			privateConstructor.setAccessible(true);//设为可访问
			User u = privateConstructor.newInstance(1);
			System.out.println("privateConstructor.newInstance() => " +u);
		} catch (NoSuchMethodException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ReflectiveOperationException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
 
}

clazz.newInstance() => User [id=0, name=unnamed, age=0]
publicConstructor.newInstance() => User [id=1, name=Bob, age=6]
privateConstructor.newInstance() => User [id=1, name=unnamed, age=0]

Method

Method提供有关类和接口上单一方法的信息和访问权限。反映的方法可以是类方法或实例方法（包括抽象方法）。

获取Method对象

为了测试我们为bean.User类添加了以下方法：

@SuppressWarnings("all")
/** 不同访问权限的方法 */
/** 私有访问权限方法 */
private void privateMethod() {
	System.out.println("do sth.(privateMethod)");
}
@SuppressWarnings("all")
private void privateMethod1(int n) {
	for(int i=0;i<n;i++)
	System.out.println("do sth.(privateMethod1)");
}
/** 受保护的访问权限方法 */
protected void protectedMethod() {
	System.out.println("do sth.(protectedMethod)");
}
/** 默认(包)访问权限的方法 */
void defaultMethod() {
	System.out.println("do sth.(defaultMethod)");
}
/** 公有访问权限的方法 */
public void publicMethod() {
	System.out.println("do sth.(publicMethod)");
}
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
@Override
public String toString() {
	return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
}

与上面Field和Constructor的获取方法类似，我们可以使用Class类的getMethods()方法和getDeclaredMethods()方法来获取一个类的构造器列表。我们也可以使用getMethod(String name,Class<?>...parameterTypes)方法提供方法名和参数列表来获取指定的方法。

@Test
public void testGetMethod() {
	User user = new User();
	Class<User> clazz = (Class<User>) user.getClass();
	/** 获取所有公有方法(包括继承的公有方法) */
	Method[] methods = clazz.getMethods();
	for (int i = 0; i < methods.length; i++) {
		System.out.println("方法:" + methods[i]);
	}
	System.out.println("-------------分隔线------------------");
	/** 获取所有声明的方法 但不包括继承方法 */
	Method[] methods1 = clazz.getDeclaredMethods();
	for (int i = 0; i < methods1.length; i++) {
		System.out.println("方法:" + methods1[i]);
	}
	System.out.println("-------------分隔线------------------");
	/** 通过方法名和参数列表获取方法 */
	try {
		Method method = clazz.getDeclaredMethod("privateMethod");
		System.out.println(method);
		Method method1 = clazz.getDeclaredMethod("privateMethod1", int.class);
		System.out.println(method1);
		/** 同样getMethod方法不能获取私有方法 */
		Method method2 = clazz.getMethod("privateMethod", int.class);
		System.out.println(method2);
	} catch (NoSuchMethodException e) {
		// TODO 自动生成的 catch 块
		System.out.println("方法未找到:" + e.getMessage());
	} catch (SecurityException e) {
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
}

方法:public java.lang.String bean.User.toString()
方法:public java.lang.String bean.User.getName()
方法:public int bean.User.getId()
方法:public void bean.User.setName(java.lang.String)
方法:public void bean.User.publicMethod()
方法:public int bean.User.getAge()
方法:public void bean.User.setAge(int)
方法:public void bean.User.setId(int)
方法:public final void java.lang.Object.wait() throws java.lang.InterruptedException
方法:public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
方法:public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
方法:public boolean java.lang.Object.equals(java.lang.Object)
方法:public native int java.lang.Object.hashCode()
方法:public final native java.lang.Class java.lang.Object.getClass()
方法:public final native void java.lang.Object.notify()
方法:public final native void java.lang.Object.notifyAll()
-------------分隔线------------------
方法:public java.lang.String bean.User.toString()
方法:public java.lang.String bean.User.getName()
方法:public int bean.User.getId()
方法:public void bean.User.setName(java.lang.String)
方法:private void bean.User.privateMethod1(int)
方法:private void bean.User.privateMethod()
方法:void bean.User.defaultMethod()
方法:protected void bean.User.protectedMethod()
方法:public void bean.User.publicMethod()
方法:public int bean.User.getAge()
方法:public void bean.User.setAge(int)
方法:public void bean.User.setId(int)
-------------分隔线------------------
private void bean.User.privateMethod()
private void bean.User.privateMethod(int)
方法未找到bean.User.privateMethod(int)

通过反射调用方法

一个Method实例可以调用invoke(Object obj,Object...args)方法来使对象obj的调用该Method实例所表示的方法，args是该方法的参数，如果此Method表示的方法是static方法，那么第一个参数会被忽略。

@Test
public void testInvokeMethod() throws Exception {
	Class<User> clazz = User.class;
	User user = clazz.newInstance();
	/** 获取并调用public方法 */
	System.out.println("/** 获取并调用public方法 */");
	Method publicMethod = clazz.getMethod("publicMethod");
	System.out.println(publicMethod);
	publicMethod.invoke(user); // 相当于调用了user.publicMethod();
	System.out.println();
	
	/** 调用其他访问权限的方法 */
	System.out.println("/** 调用其他访问权限的方法 */");
	Method privateMethod = clazz.getDeclaredMethod("privateMethod");
	privateMethod.setAccessible(true); // 关闭检查
	System.out.println(privateMethod);
	privateMethod.invoke(user);
	System.out.println();
	
	Method privateMethod1 = clazz.getDeclaredMethod("privateMethod1",int.class);//getDeclaredMethod(String name,Class<?>... patameterType)
	privateMethod1.setAccessible(true); // 关闭检查
	System.out.println(privateMethod1);
	privateMethod1.invoke(user,2);
	System.out.println();
	
	Method defaultMethod = clazz.getDeclaredMethod("defaultMethod");
	defaultMethod.setAccessible(true);// 关闭检查
	System.out.println(defaultMethod);
	defaultMethod.invoke(user);
	System.out.println();
	
	Method protectedMethod = clazz.getDeclaredMethod("protectedMethod");
	protectedMethod.setAccessible(true);// 关闭检查
	System.out.println(protectedMethod);
	protectedMethod.invoke(user);
	System.out.println();
	
	/** 调用static方法 */
	Method  staticMethod = Class.forName("java.lang.Math").getMethod("sqrt",double.class);
	System.out.println(staticMethod.invoke(null, 1024));
}

/** 获取并调用public方法 */
public void bean.User.publicMethod()
do sth.(publicMethod)

/** 调用其他访问权限的方法 */
private void bean.User.privateMethod()
do sth.(privateMethod)

private void bean.User.privateMethod1(int)
do sth.(privateMethod1)
do sth.(privateMethod1)

void bean.User.defaultMethod()
do sth.(defaultMethod)

protected void bean.User.protectedMethod()
do sth.(protectedMethod)
32.0