圈子首页 → 城市俱乐部 → 大连JAVAeyer群 → 全部博客
2007-11-14

Java反射Reflection--运行时生成instance

            想生成对象的实体，在反射动态机制中有两种方法，一个针对无变量的构造方法，一个针对带参数的构造方法，，如果想调用无参数的构造函数直接调用Class类中的newInstance（），而如果想调用有参数的构造函数，则需要调用Constructor类中newInstance（）方法，首先准备一个Class[]作为Constructor的参数类型。然后调用该Class对象的getConstructor（）方法获得一个专属的Constructor的对象，最后再准备一个Object[]作为Constructor对象昂的newInstance（）方法的实参。
            在这里需要说明的是 只有两个类拥有newInstance（）方法，分别是Class类和Constructor类，Class类中的newInstance（）方法是不带参数的，而Constructro类中的newInstance（）方法是带参数的需要提供必要的参数。

             下面提供的代码是构造Customer2类的三个构造函数
java 代码
  1. package cn.com.reflection;  
  2.   
  3. import java.lang.reflect.Constructor;  
  4. import java.lang.reflect.InvocationTargetException;  
  5.   
  6. /** 
  7.  * 在反射Reflection机制中，想生成一个类的实例有两种方法 
  8.  * 一个是针对无参数的构造函数 ，另一个是针对有参数的构造函数 
  9.  *  
  10.  */  
  11. public class ReflecTest3 {  
  12.   
  13.     /** 
  14.      * 反射的动态性质之一： 运行期动态生成Instance 
  15.      * @throws IllegalAccessException  
  16.      * @throws InstantiationException  
  17.      * @throws NoSuchMethodException  
  18.      * @throws InvocationTargetException  
  19.      * @throws SecurityException  
  20.      * @throws IllegalArgumentException  
  21.      */  
  22.     public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, SecurityException, InvocationTargetException, NoSuchMethodException {  
  23.           
  24.         Customer2 customer=new Customer2();  
  25.           
  26.         Class cls=customer.getClass();  
  27.           
  28.         //获得Class所代表的对象的所有类型的构造函数Constructor的数组  
  29.         Constructor ctor[]=cls.getDeclaredConstructors();  
  30.           
  31.         for(int i=0;i
  32.             //获得对应的构造函数参数列表的Class类型的数组  
  33.             Class cx[]=ctor[i].getParameterTypes();  
  34.           
  35.             if(cx.length==0){  
  36.                 //无参的构造函数可以通过Class实例直接调用Class类的newInstance（）方法  
  37.                 Object obj=cls.newInstance();  
  38.                 //同样也可以象以下这样构造，调用Constructor类的newInstance（）方法  
  39.                 //Customer2 obj=(Customer2)cls.getConstructor(cx).newInstance(new Object[]{});  
  40.                 System.out.println(obj);  
  41.             }else if(cx.length==2){  
  42.   //此时只能调用Constructor类的newInstance（）方法,注意：利用反射调用的是私有private的构造方法  
  43.          Customer2 obj=(Customer2)cls.getConstructor(cx).newInstance(
  44.                                    new Object[]{new Long(123),"hejianjie"});  
  45.                 System.out.println(obj);  
  46.             }else if(cx.length==3){  
  47.   //此时只能调用Constructor类的newInstance（）方法,注意：利用反射调用的是公有public的构造方法                                                                      Customer2 obj=(Customer2)cls.getConstructor(cx).newInstance(
  48.                             new Object[]{new Long(133),"China-Boy",new Integer(21)});  
  49.                 System.out.println(obj);  
  50.             }  
  51.         }  
  52.           
  53.   
  54.     }  
  55.   
  56. }  
  57.   
  58. class Customer2{  
  59.       
  60.     private Long id;  
  61.       
  62.     private String name;  
  63.       
  64.     private int age;  
  65.       
  66.     /** 
  67.      * 无参数的构造函数 
  68.      * 
  69.      */  
  70.     public Customer2(){  
  71.           
  72.     }  
  73.       
  74.     /** 
  75.      * public修饰的有参数的构造函数，3个参数 
  76.      * @param id 
  77.      * @param name 
  78.      * @param age 
  79.      */  
  80.     public Customer2(Long id,String name,int age){  
  81.        this.id=id;  
  82.        this.name=name;  
  83.        this.age=age;  
  84.     }  
  85.       
  86.     /** 
  87.      * public修饰的构造函数,2个参数 
  88.      * @param id 
  89.      * @param name 
  90.      */  
  91.     public Customer2(Long id,String name){  
  92.            this.id=id;  
  93.            this.name=name;  
  94.            this.age=age;  
  95.     }  
  96.   
  97.     public int getAge() {  
  98.         return age;  
  99.     }  
  100.   
  101.   
  102.     public void setAge(int age) {  
  103.         this.age = age;  
  104.     }  
  105.   
  106.   
  107.     public Long getId() {  
  108.         return id;  
  109.     }  
  110.   
  111.   
  112.     public void setId(Long id) {  
  113.         this.id = id;  
  114.     }  
  115.   
  116.   
  117.     public String getName() {  
  118.         return name;  
  119.     }  
  120.   
  121.   
  122.     public void setName(String name) {  
  123.         this.name = name;  
  124.     }  
  125.       
  126.     public String toString(){  
  127.         return ("id=="+this.getId()+"  Name=="+this.getName()+" Age:"+this.getAge());  
  128.     }  
  129.       
  130. }  

   程序执行结果如下：
java 代码
  1. id==123  Name==hejianjie Age:0  
  2. id==133  Name==China-Boy Age:21  
  3. id==null  Name==null Age:0  

             显然，第一行是执行的两个参数的构造函数，int类型的age初始化为0，第二行执行的是带三个参数的构造函数，最后，第三行执行的是无参数的构造函数。，Long，String类型的id，name都初始化为null，而int类型的age初始化为0。
评论
发表评论

您还没有登录，请登录后发表评论