Java反射机制探秘

桃扇骨 2021-11-11 05:08 459阅读 0赞

如何获得Class对象

  1. 1.针对每一个对象.getCalss(),可以得到对应的Class.
  2. 2.Class.forName(String),String的写法:包名.类名.就会创建包名.类名对应的那个对象
  3. 注：1.2只适用于引用类型
  4. 3.对于基本类型：封装类.TYPE代表了对应的基本类型的Class对象.Integer.TYPE对应的是int的Class对象
  5. 注：3只适用于基本类型
  6. 4.类型,Class。<第4种是通用的.>
  7. 上面的4种方法,只有方法2是动态的,只要换一个包就可以了.它具有动态潜质.所以真正意义的想体现动态编程只能使用方法2.

每种类型的Class对象只有一个,即他们的地址只有一个,但是不同类型是不同的.

所以下面的打印结果都为true.

  1. //对与引用类型
  2. Class c1 = "".getClass();
  3. Class c2 =     Class.forName("java.lang.String");
  4. Class c3 = String.class;
  5. System.out.println(c1 ==c2);//true
  6. //对于基本类型
  7. Class num1 = Integer.TYPE;
  8. Class num2 = int.class;
  9. System.out.println(num1 == num2);//true

反射获取类中的成员的相关方法

[获取构造<根据参数类型>](使用时一般用不带declared的)

  1. Constructor<T> getConstructor(Class<?>... parameterTypes) 
  2.       返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
  3.  Constructor<?>[] getConstructors() 
  4.       返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。 
  5.  Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
  6.       返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 
  7.  Constructor<?>[] getDeclaredConstructors() 
  8.       返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

[获取属性<根据属性名>](使用时一般用是带declared的,因为属性一般都是私有的)

  1. Field getField(String name) 
  2.       返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。 
  3.  Field[] getFields() 
  4.       返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。 
  5.  Field getDeclaredField(String name) 
  6.       返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 
  7.  Field[] getDeclaredFields() 
  8.       返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

[获取方法<方法名加上参数类型>](使用时一般用不带declared的)

  1. Method getMethod(String name, Class<?>... parameterTypes) 
  2.       返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 
  3.  Method[] getMethods() 
  4.       返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。 
  5.  Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
  6.       返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 
  7.  Method[] getDeclaredMethods() 
  8.       返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 
  9.  T newInstance() 
  10.       创建此 Class 对象所表示的类的一个新实例。 <new Instance()可以动态的创建对象>
  11.  String toString() 
  12.       将对象转换为字符串。

注意：

new Instance()调用的是无参构造,如果该类没有无参构造方法,则newInstance()会产生异常.

有declared的方法是支持私有,但是不支持继承,无declared的方法支持继承,不支持私有,且只能取出public的东西.

因此取属性的时候一般来说是带declared的,因为属性一般都是私有的,取方法时一般是不带declared的,取构造时一般也是不带declared的.

实例模拟反射获取类中的相关属性和方法

利用反射对属性赋值

Field中的方法

Object get(Object obj)

返回指定对象上此 Field 表示的字段的值。

  1.   Field f = c.getXXField(属性名);
  3.   值 = f.get(对象);

void set(Object obj, Object value)

将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

f.set(对象,值);

Class<?> getType()

返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。

  1.  用于获取属性的类型(返回Class对象).
  3. Class c = Student.class;
  4.     Object obj  = c.newInstance();            //创建Student类的对象
  5.     Field f = c.getDeclaredField("name");        //获取name属性
  6.     f.setAccessible(true);                    //设置私有可以访问.
  7.     f.set(obj, "zhangsan");
  8.     System.out.println(f.get(obj));             //获取obj的name属性的值.

利用反射调用构造

对于构造真正调用是在调用newInstance()方法时.

  1. Class c = Class.forName("com.clazz.reflect.Student");
  2.     Constructor con = c.getConstructor();         //没有执行构造,
  3.     Object cObj = c.getConstructor().newInstance();//调用无参的构造方法
  4.     Constructor conAll = c.getConstructor(int.class,String.class,int.class);
  5.     Object caobj = conAll.newInstance(1001,"zjamgs",234235);//调用含参的构造方法.
  6.     System.out.println(caobj);                  //打印输出

利用反射调用方法

对象.方法名(值1,2,3);

Method m = c.getMethoed(方法名，参数类型…);

m.invoke(对象,方法调用的参数 )如果底层方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null。

  1. Class c = Class.forName("com.clazz.reflect.Student");
  2.     Object obj = c.newInstance();    //创建Sutdent对象.
  3.     Method msetName = c.getMethod("setName", String.class);//obj无须转换类型
  4.     msetName.invoke(obj, "zhangsan");//调用方法setName, 并传参.
  5.     Method msetId = c.getMethod("setId", int.class);
  6.     msetId.invoke(obj, 409090202);
  7.     System.out.println(obj);

反射应用实例

实体类

  1. package org.dennisit.reflect.entity;
  2. import java.io.Serializable;
  3. /**
  4.  *
  5.  *  User.java    
  6.  *
  7.  *  @version ： 1.1
  8.  *  
  9.  *  @author  ： 苏若年    <a href="mailto:DennisIT@163.com">发送邮件</a>
  10.  *    
  11.  *  @since     ： 1.0        创建时间:    2013-2-26        下午01:43:56
  12.  *     
  13.  *  TODO     :    class User.java is used for ...
  14.  *
  15.  */
  16. public class User implements Serializable{
  18.     private String test;
  20.     public void execute(String name,int age){
  21.         System.out.println("name=" + name + ",age=" + age);
  22.     }
  23. }

反射测试类

  1. package org.dennisit.reflect.main;
  2. import java.lang.reflect.Field;
  3. /**
  4.  *
  5.  *  ReflectEx.java    
  6.  *
  7.  *  @version ： 1.1
  8.  *  
  9.  *  @author  ： 苏若年    <a href="mailto:DennisIT@163.com">发送邮件</a>
  10.  *    
  11.  *  @since     ： 1.0        创建时间:    2013-2-26        下午01:46:00
  12.  *     
  13.  *  TODO     :    class ReflectEx.java is used for ...
  14.  *
  15.  */
  16. public class ReflectEx {
  18.     public static void main(String[] args)throws Exception {
  19.         Class cls = Class.forName("org.dennisit.reflect.entity.User");
  20.         Object obj = cls.newInstance();       //创建User的对象
  21.         Field f = cls.getDeclaredField("test");    //获取test属性
  22.         f.setAccessible(true);                    //打开私有属性test的访问权限
  23.         f.set(obj, "zhangsan");                    //为test重新复制
  24.         System.out.println(f.get(obj));            //获取obj的test属性值
  25.         //根据方法名execute获取方法
  26.         java.lang.reflect.Method m = cls.getMethod("execute", String.class, int.class);
  27.         m.invoke(obj, "dennisit",23);            //调用execute方法
  28.     }
  29. }

运行效果

  1. zhangsan
  2. name=dennisit,age=23

编写一个反射动态实例化类的例子

  1. package org.dennisit.reflect.main;
  2. import java.lang.reflect.Field;
  3. import java.lang.reflect.Method;
  4. import java.util.Map;
  5. import java.util.Set;
  6. /**
  7.  *
  8.  *  DynamicReflect.java    
  9.  *
  10.  *  @version ： 1.1
  11.  *  
  12.  *  @author  ： 苏若年    <a href="mailto:DennisIT@163.com">发送邮件</a>
  13.  *    
  14.  *  @since     ： 1.0        创建时间:    2013-2-26        下午01:58:12
  15.  *     
  16.  *  TODO     :    利用反射动态实例化的例子
  17.  *
  18.  */
  19. public class DynamicReflect {
  21.     public static Object getInstance(String className,Map<String,Object> map)throws Exception{
  22.         Class c = Class.forName(className);
  23.         Object obj = c.newInstance();                //对象对象
  24.         Set<String> keys = map.keySet();            //获取对应的所有属性
  25.         Field[] fAll = c.getDeclaredFields();        //获取类中所有属性
  26.         for(int i=0;i<fAll.length;i++){
  27.             for(String key:keys){                    //循环匹配
  28.                 if(fAll[i].getName().equals(key)){    //如果用户传入的属性跟获取到的类中的属性名匹配
  29.                     Field f = c.getDeclaredField(key);//获取该属性
  30.                     //构建setXxx()方法名
  31.                     String methodName = "set" + key.substring(0,1).toUpperCase()+key.substring(1);
  32.                     Method method = c.getMethod(methodName, f.getType());//根据构建的用户名获取对应的方法
  33.                     method.invoke(obj, map.get(key));//方法调用
  34.                 }else{
  35.                     continue;
  36.                 }
  37.             }
  38.         }
  39.         return obj;
  40.     }
  41. }

接下来我们测试我们编写的动态反射实例化例子

实体类

  1. package org.dennisit.reflect.entity;
  2. import java.io.Serializable;
  3. /**
  4.  *
  5.  *  User.java    
  6.  *
  7.  *  @version ： 1.1
  8.  *  
  9.  *  @author  ： 苏若年    <a href="mailto:DennisIT@163.com">发送邮件</a>
  10.  *    
  11.  *  @since     ： 1.0        创建时间:    2013-2-26        下午01:43:56
  12.  *     
  13.  *  TODO     :    实体类
  14.  *
  15.  */
  16. public class User implements Serializable{
  18.     private String name;
  19.     private int age;
  20.     private String email;
  22.     public User() {  //必须有无参构造
  24.     }
  26.     //getter() and setter()    
  28. }

主测试类

  1. package org.dennisit.reflect.main;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import org.dennisit.reflect.entity.User;
  5. /**
  6.  *
  7.  *  ReflectEx.java    
  8.  *
  9.  *  @version ： 1.1
  10.  *  
  11.  *  @author  ： 苏若年    <a href="mailto:DennisIT@163.com">发送邮件</a>
  12.  *    
  13.  *  @since     ： 1.0        创建时间:    2013-2-26        下午01:46:00
  14.  *     
  15.  *  TODO     :    class ReflectEx.java is used for ...
  16.  *
  17.  */
  18. public class ReflectEx {
  20.     public static void main(String[] args)throws Exception {
  21.         Class cls = Class.forName("org.dennisit.reflect.entity.User");
  22.         String className = "org.dennisit.reflect.entity.User";
  23.         Map<String,Object> map = new HashMap<String, Object>();
  24.         map.put("name", "dennisit");
  25.         map.put("age", 22);
  26.         map.put("email", "dennisit@163.com");
  28.         User user = (User)DynamicReflect.getInstance(className, map);
  29.         System.out.println(user.getName() + "," + user.getAge() + "," + user.getEmail());
  30.     }
  31. }

程序运行结果

  1. dennisit,22,dennisit@163.com

转载于:https://www.cnblogs.com/coprince/p/3145866.html

发表评论

表情：
评论列表 （有 0 条评论，459人围观）

还没有评论，来说两句吧...

相关阅读

    相关 使用Java反射机制探秘

    Java的反射机制是一种强大的工具，它允许我们在运行时查看和操作类、方法以及对象的各种属性。 以下是使用Java反射机制探秘的一般步骤： 1. **获取Class对象**：

    小灰灰小灰灰/ 0 赞/ 141 阅读