概念：在某些特殊场合中编写代码时不确定要创建什么类型的对象，也不确定要调用什么样的方法，这些都希望通过运行时传递的参数来决定，该机制叫做动态编程技术，也就是反射机制
通俗来说，反射机制就是用于动态创建对象并且动态调用方法的机制
Class类：
- Class类的实例可以用于描述Java应用程序中的类和接口，也就是一种数据类型
- 该类没有公共构造方法，该类的实例由Java虚拟机和类加载器自动构造完成，本质上就是加载到内存中的运行时类
获取Class对象的方式：
- 使用数据类型.Class的方式可以获取对应类型的Class对象（较常用）
//1. 使用数据类型.class的方式可以获取对应类型的Class对象
Class c1 = String.class;
System.out.println("c1 = " + c1); //自动调用toString方法，返回类的完全限定名： class java.lang.String
c1 = int.class;
System.out.println("c1 = " + c1); //返回基本数据类型的名称 int
c1 = void.class;
System.out.println("c1 = " + c1); //返回void void
输出
- 使用引用/对象.getClass()的方式可以获取对应类型的Class对象
//2. 使用对象.getClass()的方式获取对应的Class对象
String str1 = new String("hello");
c1 = str1.getClass();
System.out.println("c1 = " + c1); //class java.lang.String
Integer it1 = 20;
c1 = it1.getClass();
System.out.println("c1 = " + c1); //class java.lang.Integer
int num = 5;
//num.getClass(); //基本数据类型的变量不能调用方法
输出
- 使用包装类.TYPE的方式可以获取对应基本数据类型的Class对象
//3. 使用包装类.TYPE的方式来获取对应基本数据类型的Class对象
c1 = Integer.TYPE;
System.out.println("c1 = " + c1); //int
输出
- 使用Class.forName()的方式来获取参数指定类型的Class对象（完整名称：包名.类名，不能获取基本数据类型的Class对象）（较常用）
//4. 调用Class类中的forName方法来获取对应的Class对象
//c1 = Class.forName("String"); //Error 必须写完整的包名
//c1 = Class.forName("int"); //不能获取基本数据类型的Class对象
c1 = Class.forName("java.lang.String");
System.out.println("c1 = " + c1); //class java.lang.String
输出
- 使用类加载器ClassLoader的方式获取指定类型的Class对象
//5. 使用类加载器的方式来获取Class对象
ClassLoader classLoader = ClassTest.class.getClassLoader();
c1 = classLoader.loadClass("java.lang.String");
System.out.println("c1 = " + c1);
输出
常用方法：
- static Class forName(String className)：用于获取参数指定类型对应的Class对象并返回
- T newInstance()：用于创建该Class对象所表示类的新实例（已过时）
/**
* 用于测试的简单Person类
*/
public class Person {
private String name;
private int age;
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;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//1. 使用原始方式以无参形式构造Person类的对象并打印
Person p1 = new Person();
System.out.println("无参方式创建的对象是：" + p1);
System.out.println("----------------------------------------------");
//2. 使用反射机制以无参行驶构造Person类型的对象并打印
Class c1 = Class.forName("Person");
System.out.println("无参方式创建的对象是：" + c1.newInstance());
输出
Constructor类：主要用于描述获取到的构造方法信息
class类常用方法：
- Constructor
getConstructor(Class... parameterTypes)：用于获取此Class对象所表示类型中参数指定的公共构造方法
//1. 使用原始方式以无参形式构造Person类的对象并打印
Person p1 = new Person();
System.out.println("无参方式创建的对象是：" + p1);
System.out.println("----------------------------------------------");
//2. 使用反射机制以无参行驶构造Person类型的对象并打印
Class c1 = Class.forName("Person");
//System.out.println("无参方式创建的对象是：" + c1.newInstance());
//获取Class对象对应类中的无参构造方法，也就是Person类中的无参构造方法
Constructor constructor = c1.getConstructor();
//使用获取到的无参构造方法来构造对应类型的对象，也就是Person类型的对象
System.out.println("无参方式创建的对象是：" + constructor.newInstance());
System.out.println("----------------------------------------------");
//3. 使用原始方式以有参方式构造Person类的对象并打印
Person p2 = new Person("张三", 20);
System.out.println("有参构造方式创建的对象是：" + p2);
System.out.println("----------------------------------------------");
//4. 使用反射机制以有参方式构造Person类型的对象并打印
//获取Class对象对应类中的有参构造方法，也就是Person类中的有参构造方法
Constructor constructor1 = c1.getConstructor(String.class, int.class);
//使用获取到的有参构造方法来构造对应类型的对象，也就是Person类型的对象
//newInstance方法中的实参是用于给有参构造方法的形参进行初始化的，也就是给name和age进行初始化的
System.out.println("有参构造方式创建的对象是：" + constructor1.newInstance("张三", 20));
输出
- Constructor[] getConstructors()：用于获取此Class对象所表示类型中所有的公共构造方法
//5. 使用反射机制获取Person类中所有的公共构造方法并打印
Constructor[] constructors = c1.getConstructors();
for (Constructor ct : constructors) {
System.out.println("构造方法的访问修饰符是：" + ct.getModifiers());
System.out.println("构造方法的方法名称是：" + ct.getName());
Class[] parameterTypes = ct.getParameterTypes();
System.out.println("构造方法的所有参数类型是：");
for (Class cs : parameterTypes) {
System.out.print(cs + " ");
}
System.out.println();
System.out.println("----------------------------------------------");
输出
相关的访问修饰符
Construcotr类常用方法：
- T newInstance(Object... initargs)：使用此Constructor对象描述的构造方法来构造Class对象代表类型的新实例
- int getModifiers()：获取方法的访问修饰符
- String getName()：获取方法的名称
- Class[] getParameterTypes()：获取方法的所有参数的类型
Field类：主要用于描述获取到的单个成员变量信息
class类常用方法：
- Field getDeclaredField(String name)：用于获取此Class对象所表示类中参数指定的单个成员变量信息
- Field[] getDeclaredFields()：用于获取此Class对象所表示类中所有成员变量信息
//1. 使用原始方式来构造对象以及获取成员变量的数值并打印
Person p1 = new Person("张三", 20);
System.out.println("获取到的成员变量数值为：" + p1.getName()); //张三
System.out.println("------------------------------------------------");
//2. 使用反射机制来构造对象以及获取成员变量的数值并打印
//2.1 获取Class对象
Class c1 = Class.forName("Person");
//2.2 根据Class对象获取对应的有参构造方法
Constructor constructor = c1.getConstructor(String.class, int.class);
//2.3 使用有参构造方法来得到Person类型的对象
Object object = constructor.newInstance("张三", 20);
//2.4 根据Class对象获取对应的成员变量信息
Field field = c1.getDeclaredField("name");
//2.5 使用Person类型的对象来获取成员变量的信息
//获取对象object中名字为field成员变量的数值，也就是成员变量name的数值
System.out.println("获取到的成员变量数值为：" + field.get(object));
输出
Field类常用方法：
Object get(Object obj)：获取参数对象obj中此Field对象所表示成员变量的数值
void set(Object obj, Object value)：将参数对象obj中此Field对象表示成员变量的数值修改为参数value的数值
void setAccessible(boolean flag)：当实参传递true时， 则反射对象在使用时应该取消Java语言访问检查
int getModifiers()：获取成员变量的访问修饰符
Class getType()：获取成员变量的数据类型
String getName()：获取成员变量的名称
//3. 使用原始方式修改指定对象中成员变量的数值后再次打印
p1.setName("李四");
System.out.println("修改后成员变量的数值为：" + p1.getName());
System.out.println("------------------------------------------------");
//4. 使用反射机制修改指定对象中成员变量的数值后再次打印
//表示修改对象object中名字为field成员变量的数值为李四，也就是成员变量name的数值为李四
field.set(object, "李四");
System.out.println("修改后成员变量的数值为：" + field.get(object));
System.out.println("------------------------------------------------");
//5. 获取Class类对象对应类中所有的成员变量
Field[] declaredFields = c1.getDeclaredFields();
for (Field ft : declaredFields) {
System.out.println("获取到的访问修饰符为：" + ft.getModifiers());
System.out.println("获取到的数据类型为：" + ft.getType());
System.out.println("获取到的成员变量名称是：" + ft.getName());
System.out.println("------------------------------------------------");
输出
Method类：主要用于描述获取到的单个成员方法信息
Class类常用方法：
- Method getMethod(String name, Class... parameterTypes)：用于获取该Class对象表示类中名字为name，参数为parameterTypes的指定公共成员方法
- Method[] getMethods()：用于获取该Class对象表示类中所有公共成员方法
Method类常用方法：
- Object invoke(Object obj, Object... args)：使用对象obj来调用此Method对象所表示的成员方法，实参传递args
- int getModifiers()：获取方法的访问修饰符
- Class getReturnType()：获取方法的返回值类型
- String getName()：获取方法的名称
- Class[] getParameterTypes()：获取方法所有参数的类型
- Class[] getExceptionTypess()：获取方法的异常信息
//1. 使用原始方式构造对象并调用方法打印结果
Person p1 = new Person("张三", 20);
System.out.println("调用方法的返回值是：" + p1.getName());
System.out.println("--------------------------------------------");
//2. 使用反射机制构造对象并调用方法打印结果
//2.1 获取Class对象
Class c1 = Class.forName("Person");
//2.2 根据Class对象来获取对应的有参构造方法
Constructor constructor = c1.getConstructor(String.class, int.class);
//2.3 使用有参构造方法构造对象并记录
Object object = constructor.newInstance("张三", 20);
//2.4 根据Class对象来获取对应的成员方法
Method method = c1.getMethod("getName");
//2.5 使用对象调用成员方法进行打印
//表示使用object对象调用method表示的方法，也就是调用getName来获取姓名
System.out.println("调用方法的返回值是：" + method.invoke(object));
System.out.println("--------------------------------------------");
//3. 使用反射机制来获取类中的所有成员方法并打印
Method[] methods = c1.getMethods();
for (Method mt : methods) {
System.out.println("成员方法的修饰符是：" + mt.getModifiers());
System.out.println("成员方法的返回值类型是：" + mt.getReturnType());
System.out.println("成员方法的名称是：" + mt.getName());
System.out.println("成员方法的形参列表是：");
Class[] parameterTypes = mt.getParameterTypes();
for (Class ct : parameterTypes) {
System.out.println(ct + "");
}
System.out.println("成员方法的异常类型列表是：");
Class[] exceptionTypes = mt.getExceptionTypes();
for (Class ct : exceptionTypes) {
System.out.println(ct + " ");
}
System.out.println();
System.out.println("--------------------------------------------");
}
输出1
输出2
输出3
获取其他结构信息的方法：
- Package getPackage()：获取所在的包的信息
- Class getSuperclass()：获取继承的父类的信息
- Class[] getInterfaces()：获取实现的所有接口
- Annotation[] getAnnotations()：获取注解信息
- Type[] getGenericInterfaces()：获取泛型信息
/**
* Student类
* @param
* @param
*/
@MyAnnotation
public class Student extends Person implements Comparable, Serializable {
@Override
public int compareTo(String o) {
return 0;
}
}
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* 自定义注解
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}
//获取Student类型的Class对象
Class c1 = Class.forName("Student");
System.out.println("获取到的包信息是：" + c1.getPackage());
System.out.println("获取到的父类信息是：" + c1.getSuperclass());
System.out.println("获取到的接口信息是：");
Class[] interfaces = c1.getInterfaces();
for (Class ct : interfaces) {
System.out.println(ct + "");
}
System.out.println();
System.out.println("-----------------------------------------------");
System.out.println("获取到的注解信息是：");
Annotation[] annotations = c1.getAnnotations();
for (Annotation at : annotations) {
System.out.println(at + " ");
}
System.out.println();
System.out.println("-----------------------------------------------");
System.out.println("获取到的泛型信息是：");
Type[] genericInterfaces = c1.getGenericInterfaces();
for (Type tt : genericInterfaces) {
System.out.println(tt + " ");
}
System.out.println();
输出