0%

反射

反射

Java提供反射来在运行时状态下动态的获取类的属性、方法等信息,在框架中很多地方都应用到了反射

反射的操作

获取Class对象

获取Class对象的四种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 第一种
Class<Person> clazz = Person.class;

// 第二种
Person person = new Person();
Class clazz1 = person.getClass();

// 第三种
String className = "com.zhanghe.study.reflect.Person";
Class clazz2 = Class.forName(className);

// 第四种 使用类加载器
ClassLoader classLoader = TestClass.class.getClassLoader();
Class clazz3 = classLoader.loadClass(className);

获取构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Class clazz = TestConstructor.class;
Constructor[] constructors = clazz.getConstructors();
System.out.println("=========clazz.getConstructors()====只能获取到公有的构造器");
for(Constructor constructor : constructors){
System.out.println(constructor);
}
System.out.println("*****************");

System.out.println("=========clazz.getConstructor()=====获取公有无参构造器");
Constructor constructor = clazz.getConstructor();
System.out.println(constructor);
System.out.println("*****************");

System.out.println("=========clazz.getDeclaredConstructors()=====获取所有构造器(包括私有、受保护、默认、公有)");
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for(Constructor declaredConstructor : declaredConstructors){
System.out.println(declaredConstructor);
}
System.out.println("*****************");

System.out.println("=========clazz.getDeclaredConstructor()====获取指定参数类型的构造器");
Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class);
System.out.println(declaredConstructor);
System.out.println("*****************");

获取属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
System.out.println("======getFields===========");
// 获取所有的属性 只能获取到该类和父类中public的
Field[] fields = clazz.getFields();
for (Field f : fields){
System.out.println(f.getName());
}
System.out.println("======getDeclaredFields===========");
// 获取所有的属性 本类中声明的所有的属性都可以获取到,不可以获取到父类的
Field[] declaredFields = clazz.getDeclaredFields();
for (Field f : declaredFields){
// 获取权限修饰符
int i = f.getModifiers();
String m = Modifier.toString(i);
System.out.println("Modifier:"+m);
// 获取属性类型
Class type = f.getType();
System.out.println("type:"+type.getTypeName());
// 获取属性名
System.out.println("name:"+f.getName());
}

获取方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
System.out.println("======getMethods===========");
// 获取本类和父类中所有的public方法
Method[] methods = clazz.getMethods();
for(Method m : methods){
System.out.println(m.getName());
}

System.out.println("======getDeclaredMethods===========");
// 获取本类中所有的方法,包括私有方法 父类的无法获取
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
// 获取注解
Annotation[] annotations = m.getAnnotations();
// 权限修饰符
System.out.println("Modifier:"+Modifier.toString(m.getModifiers()));
// 返回值类型
Class reture = m.getReturnType();
// 形参列表
Class[] params = m.getParameterTypes();
// 方法名
System.out.println(m.getName());
// 异常类型
Class[] exceptions = m.getExceptionTypes();
}

获取父类信息

1
2
3
4
5
6
7
8
9
10
// 获取父类
Class superClass = clazz.getSuperclass();

// 获取带泛型的父类
Type superType = clazz.getGenericSuperclass();

// 获取父类的泛型
if(superType instanceof ParameterizedType){ // 如果存在泛型
Type[] actualTypeArguments = ((ParameterizedType) superType).getActualTypeArguments();
}

获取接口

1
2
// 获取实现的接口
Class[] interfaces = clazz.getInterfaces();

获取包

1
2
// 获取所在的包
Package aPackage = clazz.getPackage();

获取注解

1
2
// 获取注解
Annotation[] annotations = clazz.getAnnotations();

反射为属性赋值

1
2
3
4
5
6
// 通过反射创建person实例
Person person = clazz.newInstance();
// 通过反射获取类的age属性,并赋值
Field field = clazz.getDeclaredField("age");
field.setAccessible(true);
field.set(person,20);

反射执行方法

1
2
3
// 通过反射获取方法,并调用
Method method = clazz.getMethod("display");
method.invoke(person);