文章目录
7. 反射机制
7.1 基本概念
-
通常情况下编写代码都是固定的,无论运行多少次执行的结果也是固定的,在某些特殊场合中编写
代码时不确定要创建什么类型的对象,也不确定要调用什么样的方法,这些都希望通过运行时传递
的参数来决定,该机制叫做动态编程技术,也就是反射机制。
-
反射机制就是用于动态创建对象并且动态调用方法的机制。
-
目前主流的框架底层都是采用反射机制实现的。
如:
Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象 p.show(); - 表示调用Person类中的成员方法show
7.2 Class类
7.2.1 基本概念
- java.lang.Class类的实例可以用于描述Java应用程序中的类和接口,也就是一种数据类型。
- 该类没有公共构造方法,该类的实例由Java虚拟机和类加载器自动构造完成,本质上就是加载到内存中的运行时类。
7.2.2 获取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 = boolean.class; System.out.println("c1=" + c1); //boolean c1 = void.class; System.out.println("c1=" + c1); //void
-
使用引用/对象.getClass()的方式可以获取对应类型的Class对象。(不能获取基本数据类型的对象)
//2.使用对象.getClass的方式获取对应类型的Class对象 String str = new String("hello"); c1 = str.getClass(); System.out.println("c1=" + c1); //class java.lang.String Integer it = 20; c1 = it.getClass(); System.out.println("c1=" + c1); //class java.lang.Integer System.out.println("-------------------------"); int num = 10; //int不是类 num不是对象 // c1=num.getClass; //基本数据类型的变量不能调用方法
-
使用包装类.TYPE的方式可以获取对应基本数据类型的Class对象。
//3.使用包装类.TYPE的方式获取其对应的基本数据类型的class对象 c1 = Integer.TYPE; System.out.println("c1=" + c1); //int c1 = Integer.class; System.out.println("c1=" + c1); //java.lang.Integer System.out.println("-------------------------");
-
使用Class.forName()的方式来获取参数指定类型的Class对象(掌握)。(不能获取基本数据类型的对象)
//4.通过调用Class类中的forName方法来获取对象的class对象 // c1=Class.forName("String"); Error 要求写完整的名称:包名.类名 c1 = Class.forName("java.lang.Integer"); System.out.println("c1=" + c1); //java.lang.Integer c1 = Class.forName("java.util.Date"); System.out.println("c1=" + c1); //java.util.Date // c1 = Class.forName("int"); // System.out.println("c1=" + c1); 不能获取基本数据类型的对象 System.out.println("----------------------------------");
-
使用类加载器ClassLoader的方式获取指定类型的Class对象。
//5.使用类加载器的方式来获取对象 ClassLoader classLoader = ClassTest.class.getClassLoader();//类加载器 System.out.println("classLoader=" + classLoader); // c1 = classLoader.loadClass("java.lang.String"); System.out.println("c1="+c1); //java.lang.String
7.2.3 常用的方法(掌握)
方法声明 | 功能介绍 |
---|---|
static Class<?> forName(String className) | 用于获取参数指定类型对应的Class对象并返回 |
T newInstance() | 用于创建该Class对象所表示类的新实例 |
Class c1 = Class.forName("demo05.Person");
System.out.println("使用无参方式创建的对象是:" + c1.newInstance());
7.3 Constructor类
7.3.1 基本概念
java.lang.reflect.Constructor类主要用于描述获取到的构造方法信息
7.3.2 Class类的常用方法
方法声明 | 功能介绍 |
---|---|
Constructor getConstructor(Class<?>…parameterTypes) | 用于获取此Class对象所表示类型中参数指定的公共构造方法 |
Constructor<?>[] getConstructors() | 用于获取此Class对象所表示类型中所有的公共构造方法 |
//2.1 获取Class对象
Class c1 = Class.forName("demo05.Person");
//2.2 根据Class对象来获取对应类型的有参构造方法
Constructor constructor = c1.getConstructor(String.class, int.class);
7.3.3 Constructor类的常用方法
方法声明 | 功能介绍 |
---|---|
T newInstance(Object…initargs) | 使用此Constructor对象描述的构造方法来构造Class对象代表类型的新实例 |
int getModifiers() | 获取方法的访问修饰符 |
String getName() | 获取方法的名称 |
Class<?>[ ]getParameterTypes() | 获取方法所有参数的类型 |
public class Person {
public String name;
private int age;
......
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class PersonConstructorTest {
public static void main(String[] args) throws Exception {
//1.使用原始方式以无参形式构造Person类型的对象
Person p1 = new Person();
System.out.println("使用无参方式创建的对象是:" + p1);
System.out.println("-------------------------");
//2.使用反射机制以无参形式构造Person类型的对象
Class c1 = Class.forName("demo05.Person");
System.out.println("使用无参方式创建的对象是:" + c1.newInstance());
//创建对象的类型可以使用键盘输入
System.out.println("请输入要创建的类型:");
Scanner sc = new Scanner(System.in);
String str = sc.next();
c1 = Class.forName(str);
System.out.println("键盘输入的类型是:" + c1.newInstance());
sc.close();
//读取配置文件的方式创建类型的对象
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("e:/a.txt")));
String str1 = br.readLine();
c1 = Class.forName(str1);
System.out.println("配置文件读取的类型是:" + c1.newInstance());
br.close();
System.out.println("========================");
//3.获取Class对象对应类的类的无参构造方法,也就是Person类中的无参构造方法
Constructor constructor = c1.getConstructor();
//使用对象中的无参构造方法也构造对应类型的对象,也就是Person类型的对象
System.out.println("使用无参方式构造的对象是:" + constructor.newInstance());
System.out.println("---------------------------------------------");
//获取Class对象对应类的有参构造方法类构造对象
Constructor constructor1 = c1.getConstructor(String.class, int.class);
//使用获取到的构造方法来构造对应类型的对象
//newInstance方法中实参实际上是给有参构造方法中的形参进行初始化
System.out.println("使用有参构造方式创建的对象是:" + constructor1.newInstance("阿七", 25));
System.out.println("-------------------------------------");
//4.使用反射机制获取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.print("构造方法的所有参数类型是:");
for (Class ca : parameterTypes) {
System.out.print(ca+" ");
}
System.out.println();
System.out.println("-------------------------------");
}
}
}
7.4 Field类
7.4.1 基本概念
java.lang.reflect.Field类主要用于描述获取到的单个成员变量信息。
7.4.2 Class类的常用方法
方法声明 | 功能介绍 |
---|---|
Field getDeclaredField(String name) | 用于获取此Class对象所表示类中参数指定的单个成员变量信息 |
Field[] getDeclaredFields() | 用于获取此Class对象所表示类中所有成员变量信息 |
//1.使用原始方式来构造对象并获取成员变量并打印
Person p1 = new Person("阿七", 25);
System.out.println("获取到的成员变量的数值为:" + p1.name);
System.out.println("-----------------------------");
//2.使用反射机制构造对象并获取成员变量并打印
//2.1 获取Class对象
Class c1 = Class.forName("demo05.Person");
//2.2 根据Class对象来获取对应类型的有参构造方法
Constructor constructor = c1.getConstructor(String.class, int.class);
//2.3 使用有参构造方法来得到Person类型的对象
Object object = constructor.newInstance("阿七", 25);
//2.4 根据Class对象获取对应成员变量的信息
Field field = c1.getDeclaredField("name");
//设置Java语言访问的检查的取消 暴力反射
field.setAccessible(true); //当访问的成员变量为私有成员变量时
//2.5 使用Person类型的对象来获取成员变量的数值并打印
//获取对象object中名字为field成员变量的数值,也就是成员变量name的数值
System.out.println("获取到的成员变量的数值为:" + field.get(object));
System.out.println("-----------------------------------------");
//3.使用原始方式修改指定对象的成员变量的值并打印
p1.name = "周扬";
System.out.println("修改后的成员变量的值为:" + p1.name);
//4.使用反射机制来修改指定对象的成员变量的值
//修改对象object中名字为field成员变量的数值
field.set(object, "周扬");
System.out.println("修改后的成员变量的值为:" + field.get(object));
System.out.println("------------------------------");
7.4.3 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() | 获取成员变量的名称 |
//设置Java语言访问的检查的取消 暴力反射
field.setAccessible(true); //当访问的成员变量为私有成员变量时
//修改对象object中名字为field成员变量的数值
field.set(object, "周扬");
//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("--------------------------------");
7.5 Method类
7.5.1 基本概念
- java.lang.reflect.Method类主要用于描述获取到的单个成员方法信息。
7.5.2 Class类的常用方法
方法声明 | 功能介绍 |
---|---|
Method getMethod(String name,Class<?>… parameterTypes) | 用于获取该Class对象表示类中名字为name参数为parameterTypes的指定公共成员方法 |
Method[] getMethods() | 用于获取该Class对象表示类中所有公共成员方法 |
7.5.3 Method类的常用方法
方法声明 | 功能介绍 |
---|---|
Object invoke(Object obj,Object… args) | 使用对象obj来调用此Method对象所表示的成员方法,实参传递args |
int getModifiers() | 获取方法的访问修饰符 |
Class<?> getReturnType() | 获取方法的返回值类型 |
String getName() | 获取方法的名称 |
Class<?>[] getParameterTypes() | 获取方法所有参数的类型 |
Class<?>[] getExceptionTypes() | 获取方法的异常信息 |
package demo05;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class PersonMethodTest {
public static void main(String[] args) throws Exception {
//1.使用原始方式构造对象并调用方法打印结果
Person p1 = new Person("海棠", 18);
System.out.println("调用方法的返回值为:" + p1.getName());
System.out.println("-------------------------------");
//2.使用反射机制构造对象并调用方法打印结果
//2.1 获取Class对象
Class c1 = Class.forName("demo05.Person");
//2.2 根据Class对象来获取对应的有参构造方法
Constructor constructor = c1.getConstructor(String.class, int.class);
//2.3 使用有参构造方法来构造对象并记录
Object object = constructor.newInstance("海棠", 18);
//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.print("成员方法的形参列表是:");
Class<?>[] parameterTypes = mt.getParameterTypes();
for (Class ct:parameterTypes) {
System.out.print(ct+" ");
}
System.out.println();
System.out.println("成员方法中的异常类型是:");
Class<?>[] exceptionTypes = mt.getExceptionTypes();
for (Class ct:exceptionTypes) {
System.out.print(ct);
}
System.out.println();
System.out.println("-------------------------");
}
}
}
7.6 获取其它结构信息
方法声明 | 功能介绍 |
---|---|
Package getPackage() | 获取所在的包信息 |
Class<? super T> getSuperclass() | 获取继承的父类信息 |
Class<?>[] getInterfaces() | 获取实现的所有接口 |
Annotation[] getAnnotations() | 获取注解信息 |
Type[] getGenericInterfaces() | 获取泛型信息 |
//父类
public class Person {
public String name;
private int age;
......
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//子类
package demo05;
import java.io.Serializable;
@MyAnnotation
public class Student<T,E> extends Person implements Comparable<String>, Serializable { //指定的泛型信息
@Override
public int compareTo(String o) {
return 0;
}
}
public class StudentTest {
public static void main(String[] args) throws Exception {
//获取Student类型的Class对象
Class c1 = Class.forName("demo05.Student");
System.out.println("获取到的包信息是:" + c1.getPackage());
System.out.println("获取到的父类信息是:" + c1.getSuperclass());
System.out.println("---------------------------------");
System.out.println("获取到的接口信息是:");
Class[] interfaces = c1.getInterfaces();
for (Class ca : interfaces) {
System.out.print(ca+" ");
}
System.out.println();
System.out.println("--------------------------------");
System.out.println("获取到的注解信息是:");
Annotation[] annotations = c1.getAnnotations();
for (Annotation at : annotations) {
System.out.print(at+" ");
}
System.out.println();
System.out.println("---------------------------------");
//泛型
Type[] genericInterfaces = c1.getGenericInterfaces();
for (Type tp:genericInterfaces) {
System.out.print(tp+" ");
}
System.out.println();
}
}