点击刷新
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取类信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：
- 在运行时构造任意一个类的对象
- 在运行时获取任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的方法（属性）
- 生成动态代理
Class 是一个类; 一个描述类的类.
封装了描述方法的 Method,
描述字段的 Filed,
描述构造器的 Constructor 等属性.
eg:定义Person类、Student类、Student继承Person
package reflect; public class Person { String name; private int age; private Integer sal; public String getName() { return name; } public void setName(String name) { this.name = name; System.out.println("执行了setName()方法"); } public int getAge() { return age; } public void setAge(int age) { this.age = age; System.out.println("执行了setAge()方法"); } public Integer getSal() { return sal; } public void setSal(Integer sal) { this.sal = sal; System.out.println("执行了setAge()方法"); } public Person(String name, int age, Integer sal) { super(); this.name = name; this.age = age; this.sal = sal; } public Person() { super(); } private void Say(){ System.out.println("我好痛苦,我觉得生不如死!"); } public void test(String name,Integer sal){ System.out.println("调用成功"); } }
package reflect; public class Student extends Person{ private Double score; public Double getScore() { return score; } public void setScore(Double score) { this.score = score; } private void Study(){ System.out.println("我太累了，不想学习"); } }
1、如何描述方法-Method（getDeclaredMethod()不能获取父类方法 getMethod() 一般只能获取私有方法）
@Test public void testMethod() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{ Class clazz=Class.forName("reflect.Person"); //1、获取clazz对应类中的所有方法--方法数组1 Method[] methods=clazz.getMethods(); for(Method method:methods){ System.out.println(method.getName()); } System.out.println("-----------------------------------------------------"); //2、获取所有方法包括私有方法---方法数组2 methods=clazz.getDeclaredMethods(); for(Method method:methods){ System.out.println(method.getName()); } //3.1、获取指定的方法 //需要参数名称和参数列表，无参则不需要 //对于方法 public void setName(String name){} Method method=clazz.getDeclaredMethod("setName",String.class); System.out.println(method); //而对于方法public void setAge(int age){} method=clazz.getDeclaredMethod("setAge",int.class); System.out.println(method); method=clazz.getDeclaredMethod("setSal",Integer.class ); System.out.println(method); //4、执行方法 invoke() 第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要转入的参数 Object obj=clazz.newInstance(); method.invoke(obj, 2000); //如果一个方法是私有方法，3.1是可以获取到的，但是这一步却不能执行 //私有方法的执行，必须在调用invoke之前加上一句method.setAccessible(true) method=clazz.getDeclaredMethod("Say",null); method.setAccessible(true); method.invoke(obj, null); }
主要用到的两个方法
/** * @param name the name of the method * @param parameterTypes the list of parameters * @return the {@code Method} object that matches the specified */ public Method getMethod(String name, Class<?>... parameterTypes){ } /** * @param obj the object the underlying method is invoked from * @param args the arguments used for the method call * @return the result of dispatching the method represented by */ public Object invoke(Object obj, Object... args){ }
自定义工具方法
自定义一个方法
把类对象和类方法名作为参数，执行方法
把全类名和方法名作为参数，执行方法
假设：Person类里面有一个方法
public void test(String name,Integer sal){ System.out.println("调用成功"); }
1. 把类对象和类方法名作为参数，执行方法(下面的方法没有考虑到无参的方法)
/** * @param obj: 方法执行的那个对象. * @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法. * @param args: 调用该方法需要传入的参数 * @return: 调用方法后的返回值 * 把类对象和类方法名作为参数，执行方法 */ public Object invoke(Object obj,String methodName,Object ... args) throws Exception{ //1、获取Method对象 //因为getMethod的参数为Class类型，所以要把参数args转换为对应的Class类型 Class[] parameterTypes=new Class[args.length]; for(int i=0;i<args.length;i++){ parameterTypes[i]=args[i].getClass(); System.out.println(parameterTypes[i]); } Method method=obj.getClass().getDeclaredMethod(methodName, parameterTypes); //如果使用getDeclaredMethod(),就不能获取父类方法，如果使用getMethod()就不能获取私有方法 //2、执行Method方法 //返回方法返回值 return method.invoke(obj, args); }
@Test public void testInvoke() throws Exception{ Object obj=new Person(); invoke(obj,"test","李刚",20000); }
2.把全类名和方法名作为参数，执行方法(没有考考虑无参的方法)
public Object invoke(String className,String methodName,Object...args){ Object obj=null; try{ obj=Class.forName(className).newInstance(); return invoke(obj,methodName,args); }catch(Exception e){ e.printStackTrace(); } return null; }
这种反射实现的主要功能是可配置和低耦合。只需要类名和方法名，而不需要一个类对象就可以执行一个方法。如果我们把全类名和方法名放在一个配置文件中，就可以根据调用配置文件来执行方法
如何获取父类定义的（私有）方法
前面说一般使用getDeclaredMethod获取方法（因为此方法可以获取类的私有方法，但是不能获取父类方法）
如何获取父类方法呢，getMethod
首先我们要知道，如何获取类的父亲：
比如有一个类，继承自Person
@Test public void testGetSuperClass() throws Exception{ String className="reflect.Student"; Class clazz=Class.forName(className); Class superClazz=clazz.getSuperclass(); System.out.println(superClazz);//class reflect.Person }
此时如果Student中有一个方法是私有方法method1(int age); Person中有一个私有方法method2();
怎么调用 定义一个方法，不但能访问当前类的私有方法，还要能父类的私有方法
/** * * @param obj: 某个类的一个对象 * @param methodName: 类的一个方法的方法名. * 该方法也可能是私有方法, 还可能是该方法在父类中定义的(私有)方法 * @param args: 调用该方法需要传入的参数 * @return: 调用方法后的返回值*/ public Object invoke2(Object obj,String methodName,Object... args){ Class[] parameterTypes=new Class[args.length]; for(int i = 0; i < args.length; i++){ parameterTypes[i] = args[i].getClass(); } try{ Method method=getMethod(obj.getClass(),methodName,parameterTypes); method.setAccessible(true); return method.invoke(obj, args); }catch(Exception e){ e.printStackTrace(); } return null; } /** * 获取 clazz 的 methodName 方法. 该方法可能是私有方法, 还可能在父类中(私有方法) * 如果在该类中找不到此方法，就向他的父类找，一直到Object类为止 * 这个方法的另一个作用是根据一个类名，一个方法名，追踪到并获得此方法*/ public Method getMethod(Class clazz,String methodName,Class ...parameterTypes){ for(;clazz!=Object.class;clazz=clazz.getSuperclass()){ try{ Method method=clazz.getDeclaredMethod(methodName, parameterTypes); return method; }catch(Exception e){ } } return null; }
3.2 如何描述字段-Field
@Test public void testField() throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{ String className="reflect.Person"; Class clazz=Class.forName(className); //1、获取字段 //获取所有字段，字段数组 //可以获取公用和私有的所有字段，但不能获取父类字段 Field[] fields=clazz.getDeclaredFields(); for(Field field:fields){ System.out.println(field); } Person person=new Person(); person.setName("郭维平"); person.setSal(6000); //1.2获取指定字段 Field field=clazz.getDeclaredField("name"); System.out.println("-----字段名称-------"+field.getName()); //2、使用字段 //2.1获取指定对象的指定字段的值 Object val=field.get(person); System.out.println(val); field.set(person, "周益涛"); System.out.println(person.getName()); field=clazz.getDeclaredField("age"); field.setAccessible(true);//如果字段是私有的，不管是读值还是写值，都必须先调用setAccessible(true);比如Person类中，字段name字段是公用的，age是私有的 System.out.println("--------age---------"+field.get(person)); }
输出结果：
java.lang.String com.idea.test.Person.name private int com.idea.test.Person.age private java.lang.Integer com.idea.test.Person.sal 执行了setName()方法 执行了setAge()方法 -----字段名称-------name 郭维平 周益涛 --------age---------0
但是如果需要访问父类中的（私有）字段：（好像有点问题需注意）
@Test public void testField() throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException{ //创建className对应类的对象，并为其fieldName赋值val //Student继承自Person,age是Person类的私有字段 String className="reflect.Student"; String fieldName="age"; Object val=26; Object obj=null; //1、创建className对应类的对象 Class clazz=Class.forName(className); //2、创建fieldName对象字段的对象 Field field=getField(clazz,fieldName); //3、为此对象赋值 obj=clazz.newInstance(); setFieldValue(obj,field,val); //4、获取此对象的值 Object value=getFieldValue(obj,field); } public Object getFieldValue(Object obj,Field field) throws IllegalArgumentException, IllegalAccessException{ field.setAccessible(true); return field.get(obj); } public void setFieldValue(Object obj,Field field,Object val) throws IllegalArgumentException, IllegalAccessException{ field.setAccessible(true); field.set(obj, val); } public Field getField(Class clazz,String fieldName) throws NoSuchFieldException, SecurityException{ Field field= null; for(Class clazz2=clazz;clazz2!=Object.class;clazz2=clazz2.getSuperclass()){ field=clazz2.getDeclaredField(fieldName); } return field; }
3.3如何描述构造器-Constructor
@Test
public void testConstructor() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
String className="reflect.Person";
Class<Person> clazz=(Class<Person>)Class.forName(className);
//1、获取Constructor对象
//1.1获取全部
Constructor<Person>[] constructors=(Constructor<Person>[])clazz.getConstructors();
for(Constructor constructor:constructors){
System.out.println(constructor);
}
// // 1.2获取某一个，需要参数列表
Constructor<Person> constructor=clazz.getConstructor(String.class,int.class,Integer.class);
Object obj=constructor.newInstance("周益涛",18,10000);
System.out.println("-----"+obj.toString());
}
3.4 如何描述注解 -- Annotation
package reflect; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME) @Target(value={ElementType.METHOD}) public @interface AgeValidator { public int min(); public int max(); }
此注解只能用在方法上
@AgeValidator(min=12,max=30) public void setAge(int age) { this.age = age; System.out.println("执行了setAge()方法"); }
那么我们在给Person类对象的age赋值时，是感觉不到注解的存在的
@Test public void testAnnotation(){ Person p=new Person(); p.setAge(15); }
必须通过反射的方式为属性赋值，才能获取到注解
@Test public void testAnnotation1() throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException{ String className="reflect.Person"; Class clazz=Class.forName(className); Object obj=clazz.newInstance(); Method method=clazz.getDeclaredMethod("setAge",int.class); int val=6; //获取指定名称的注解 Annotation annotation=method.getAnnotation(AgeValidator.class); if(annotation!=null){ if(annotation instanceof AgeValidator){ AgeValidator ageValidator=(AgeValidator)annotation; if(val<ageValidator.min() ||val>ageValidator.max()){ throw new RuntimeException("年龄非法"); } } } }
反射小结
1. Class: 是一个类; 一个描述类的类.
封装了描述方法的 Method,
描述字段的 Filed,
描述构造器的 Constructor 等属性.
2. 如何得到 Class 对象:
2.1 Person.class
2.2 person.getClass()
2.3 Class.forName("com.atguigu.javase.Person")
3. 关于 Method:
3.1 如何获取 Method:
1). getDeclaredMethods: 得到 Method 的数组.
2). getDeclaredMethod(String methondName, Class ... parameterTypes)
3.2 如何调用 Method
1). 如果方法时 private 修饰的, 需要先调用 Method 的 setAccessible(true), 使其变为可访问
2). method.invoke(obj, Object ... args);
4. 关于 Field:
4.1 如何获取 Field: getField(String fieldName)
4.2 如何获取 Field 的值:
1). setAccessible(true)
2). field.get(Object obj)
4.3 如何设置 Field 的值:
field.set(Obejct obj, Object val)
5. 了解 Constructor 和 Annotation
6. 反射和泛型.
6.1 getGenericSuperClass: 获取带泛型参数的父类, 返回值为: BaseDao<Employee, String>
6.2 Type 的子接口: ParameterizedType
6.3 可以调用 ParameterizedType 的 Type[] getActualTypeArguments() 获取泛型参数的数组
© 著作权归作者所有
举报
发表评论
0/200
