Java反射机制基础使用总结

1、什么是反射？

反射(Reflection)是一种动态操作类的机制，它允许运行中的Java程序对自身进行检查，及在运行状态中对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。及在程序运行状态下动态的获取类的信息以及动态的调用类对象的方法。

2、反射API

反射可以将Java类中的各个组成部分，映射成一个个的不同类型的Java对象。

相关类	用途
Class类	代表类的定义
Method类	代表类的方法
Field类	代表类的成员变量
Constructor类	代表类的构造方法

3、Class类

Class代表类的实体，在运行的Java应用程序中表示类和接口。Class获得方法和Class相关方法如下：
3.1、获得Class的三种方法（以String为例）

• 使用 Class.forName 静态方法：Class.forName(“类的完全限定名”)

Class stringClass = Class.forName(“java.lang.String”);

• 使用类型的class()方法：类名.class

Class stringClass = String.class();

• 使用对象的getClass()方法：对象名.getClass()

String str = new String(“String”);
Class stringClass = str.getClass();

3.2、Class类用来获取类相关的方法

方法	用途
forName(String className)	根据类名返回类的对象
newInstance()	创建类的实例
getName()	获得类的完全限定名
getSimpleName()	获得类的名字
getPackage()	获得类的包名
getSuperclass()	获得当前类继承的父类的名字
getInterface()	获得当前类实现的接口的名字

相关方法代码测试类：

public class Demo_02 {
	public static void main(String[] args) {
		try {
			//1、获取Class类对象
			Class stuClass = Class.forName("com.apesourec.entity.Student");
			//2、创建实例
			Object stu1 = stuClass.newInstance();
			Object stu2 = stuClass.newInstance();
			Object stu3 = stuClass.newInstance();
			//3、输出
			System.out.println(stu1);
			System.out.println(stu2);
			System.out.println(stu3);
			//4、输出简单类名、完全限定名
			System.out.println("完全限定名："+stuClass.getName());
			System.out.println("简单类名："+stuClass.getSimpleName());
			//5、获取当前Class类的父类Class对象
			Class superClass = stuClass.getSuperclass();
			System.out.println("父类对象名称："+superClass);
			//6、获取当前Class类的实现接口的Class对象
			Class [] interfaces  = stuClass.getInterfaces();
			System.out.println("实现接口："+Arrays.toString(interfaces));
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}
}

控制台输出结果如下：

3.3、Class用来获得类中属性相关的方法（Field类型对象）

方法	用途
getField(String name)	获得某个公有的属性对象
getFields()	获得所有公有的属性对象
getDeclaredField(String name)	获得某个属性对象
getDeclaredFields()	获得所有属性对象

相关方法代码测试类：

/*
 * 通过反射提取成员变量
 */
public class Demo_03 {
	public static void main(String[] args) {
		//获取Class对象
		Class stuClass = Student.class;
		//通过Class对象获取成员变量
		//获取所有公有成员变量
		System.out.println("======获取所有公有成员变量======");
		Field[] fields = stuClass.getFields();
		for(Field i : fields) {
			System.out.println(i);
		}
		System.out.println("--------------------------------");
		//获取指定公有成员变量
		try {
			Field nameField = stuClass.getField("name");
			System.out.println("指定公有name成员变量："+nameField);
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		//获取所有成员变量
		System.out.println("======获取所有成员变量（公有+私有）======");
		Field [] declaredFields = stuClass.getDeclaredFields();
		for(Field i : declaredFields) {
			System.out.println(i);
		}
		//获取指定成员变量
		try {
			Field declaredField = stuClass.getDeclaredField("sex");
			System.out.println("指定私有sex成员变量："+declaredField);
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
	}
}

控制台输出结果如下：

3.4、Class类 获得类中构造器相关的方法（Constructor类型对象）

方法	用途
getConstructor(Class… parameterTypes)	获得该类中与参数类型匹配的公有构造方法
getConstructors()	获得该类的所有公有构造方法
getDeclaredConstructor(Class… parameterTypes)	获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()	获得该类所有构造方法

相关方法代码测试类：

/*
 * 提取构造器
 */
public class Demo_04 {
	public static void main(String[] args) {
		Class stuClass = Student.class;
		//获取所有构造器
		Constructor[] constructors = stuClass.getDeclaredConstructors();
		System.out.println("=======所有构造方法=======");
		for(Constructor i : constructors) {
			System.out.println(i);
		}
		//获取指定构造方法
		//获取无参构造方法
		try {
			Constructor constructor = stuClass.getDeclaredConstructor();
			System.out.println("获取无参构造方法："+constructor);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		//获取参数为int的构造方法
		try {
			Constructor intconstructor = stuClass.getDeclaredConstructor(int.class);
			System.out.println("参数为int的构造方法："+intconstructor);
			//获取2个参数的构造方法
			Constructor constructor2 = stuClass.getDeclaredConstructor(double.class,String.class);
			System.out.println("参数为两个的构造方法为："+constructor2);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}	
	}
}

控制台输出结果如下：

3.5、Class类获得类中方法相关的方法（Method类型对象）

方法	用途
getMethod(String name, Class… parameterTypes)	获得该类某个公有的方法
getMethods()	获得该类所有公有的方法
getDeclaredMethod(String name, Class… parameterTypes)	获得该类某个方法
getDeclaredMethods()	获得该类所有方法

相关方法代码测试类：

/*
 * 提取方法
 */
public class Demo_05 {
	public static void main(String[] args) {
		Class objClass = Object.class;
		//获取Object类中的所有方法
		Method[] methods = objClass.getDeclaredMethods();
		for(Method method : methods) {
			System.out.println(method);
		} 
		//获取Object类中的指定方法
		try {
			Method waitmethod = objClass.getDeclaredMethod("wait", long.class,int.class);
			System.out.println("Object中的wait方法"+waitmethod);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
	}
}

控制台输出结果如下：

3、Field类

Field代表类的成员变量（成员变量也称为类的属性）。相关方法与用途如下：

方法	用途
equals(Object obj)	属性与obj相等则返回true
get(Object obj)	获得obj中对应的属性值
set(Object obj, Object value)	设置obj中对应属性值
setAccessible(boolean flag)	设置私有属性是否可访问

相关方法代码测试类：

/*
 * 使用反射给成员变量赋值
 */
public class Demo_06 {
	public static void main(String[] args) {
		try {
			//1、创建实例对象
			Class stuClass = Student.class;
			Object stuObj = stuClass.newInstance();
			//2、获取用于赋值的私有成员变量
			Field stuIdField = stuClass.getDeclaredField("stuId");
			//3、设置允许访问私有变量
			stuIdField.setAccessible(true);
			//4、对成员变量进行赋值
			stuIdField.set(stuObj, "123456");
			System.out.println(stuObj);
		} catch (InstantiationException e) { 
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}
}

控制台输出结果如下：

4、Method类

Method代表类的方法，它相关方法如下：

方法	用途
invoke(Object obj, Object… args)	传递object对象及参数调用该对象对应的方法
getModifiers( )	返回方法访问修饰符
getParameters( )	返回方法参数
getReturnType( )	返回返回值类型Class
setAccessible(boolean flag)	设置私有方法是否可访问

相关方法代码测试类：

/*
 * 以反射方式调用方法
 */
public class Demo_07 {
	public static void main(String[] args) {
		//方法的普通调用
		Student stu = new Student();
		stu.test(1, "普通调用");
		//反射方式调用方法
		//1、获取类的Class并创建实例
		try {
			Class stuClass = Class.forName("com.apesourec.entity.Student");
			Object stu1 = stuClass.newInstance();
			
			//2、获取方法对象
			Method testmethod = stuClass.getDeclaredMethod("test", int.class,String.class);
			//3、执行方法
			testmethod.invoke(stu1, 2,"反射调用");
			
			//4、输出方法的具体信息
			System.out.println("获取方法的名称："+testmethod.getName());
			System.out.println("获取方法的访问修饰符："+testmethod.getModifiers());
			System.out.println("方法的访问修饰符是否为private："+(testmethod.getModifiers()==Modifier.PRIVATE));
			//5、获取方法参数列表
			Parameter[] par = testmethod.getParameters();
			System.out.println("参数列表："+Arrays.toString(par));
			System.out.println("参数个数："+testmethod.getParameterCount());
			//6、获取方法返回值类型
			Class rt = testmethod.getReturnType();
			System.out.println("方法返回类型为："+rt);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
}

控制台输出结果如下：

5、Constructor类

Constructor代表类的构造方法，它的相关方法如下：

方法	用途
newInstance(Object… initargs)	根据传递的参数创建类的对象
setAccessible(boolean flag)	设置私有构造方法是否可访问

相关方法代码测试类：

/*
 * 反射调用有参构造函数
 */
public class Demo_08 {
	public static void main(String[] args) {
		Class stuClass = Student.class;
		//调用无参构造方法实例化对象
		try {
			Object obj = stuClass.newInstance();
			//使用带有参数得到构造方法实例化对象
			//获取带有参数的私有构造方法
			Constructor con = stuClass.getDeclaredConstructor(int.class,String.class);
			//允许私有访问
			con.setAccessible(true);
			//通过该构造方法实例化对象
			Object objstu = con.newInstance(15,"张三");
			System.out.println(objstu);
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
}

控制台输出结果如下：

---

总结

• 反射机制极大的提高了程序的灵活性和扩展性，降低模块的耦合性，提高自身的适应能力。
• 通过反射机制可以让程序创建和控制任何类的对象，无需提前硬编码目标类。
• 使用反射机制能够在运行时构造一个类的对象、判断一个类所具有的成员变量和方法、调用一个对象的方法。
• 反射机制是构建框架技术的基础所在，使用反射可以避免将代码写死在框架中。