黑马程序员技术交流社区

标题: 访问构造方法的反射代码哪出现了问题？ [打印本页]
作者: 张yy    时间: 2013-7-19 13:13
标题: 访问构造方法的反射代码哪出现了问题？
本帖最后由 张yy 于 2013-7-20 15:37 编辑

通过反射  访问构造方法
代码如下：
  1. class Example_01 {

  3.         String s;
  4.         int i,i2,i3;
  5.         private Example_01(){
  6.                
  7.         }
  8.         
  9.         protected Example_01(String s,int i){
  10.                 this.s = s;
  11.                 this.i = i;
  12.         }
  13.         
  14.         public Example_01(String...strings)throws NumberFormatException{
  15.                
  16.                 if(strings.length>0)
  17.                         i = Integer.valueOf(strings[0]);
  18.                 if(strings.length>1)
  19.                         i2 = Integer.valueOf(strings[1]);
  20.                 if(strings.length>2)
  21.                         i3 = Integer.valueOf(strings[2]);
  22.                
  23.         }
  24.         
  25.         public void print(){
  26.                 System.out.println("s="+s);
  27.                 System.out.println("i="+i);
  28.                 System.out.println("i2="+i2);
  29.                 System.out.println("i3="+i3);
  30.         }

  32. }
复制代码

  2. import java.lang.reflect.*;

  4. public class Reflect_Constructor {

  6.         /**
  7.          * @param args
  8.          */
  9.         public static void main(String[] args) {
  10.                 Example_01 example = new Example_01();
  11.                 Class exampleC = example.getClass();
  12.                
  13.                 //获取所有构造方法
  14.                 Constructor[] declaredConstructors = exampleC.getDeclaredConstructors();
  15.                
  16.                 for(int i=0;i<declaredConstructors.length;i++){
  17.                         //遍历构造方法
  18.                         Constructor constructor = declaredConstructors[i];
  19.                         System.out.println("查看是否允许带有可变数量的参数：" + constructor.isVarArgs());
  20.                         
  21.                         System.out.println("该构造方法的入口参数类型依次为：");
  22.                         //获取所有参数类型
  23.                         Class[] parameterTypes = constructor.getParameterTypes();
  24.                         for(int j=0;j<parameterTypes.length;j++){
  25.                                 System.out.println(""+parameterTypes[j]);
  26.                         }
  27.                         
  28.                         System.out.println("该构造方法可能抛出的异常类型为：");
  29.                         //获取所有可能抛出的异常信息类型
  30.                         Class[] exceptionTypes = constructor.getExceptionTypes();
  31.                         for(int j=0;j<exceptionTypes.length;j++){
  32.                                 System.out.println(""+exceptionTypes[j]);
  33.                         }
  34.                         
  35.                         
  36.                         Example_01 example2 = null;
  37.                         while(example2 == null){
  38.                                 //如果该成员变量的访问权限为private，则抛出异常，即无法访问
  39.                                 try{
  40.                                         //通过执行默认没有参数的构造方法创建对象
  41.                                         if(i == 2)
  42.                                                 example2 = (Example_01) constructor.newInstance();
  43.                                        
  44.                                         //通过执行具有两个参数的构造方法创建对象
  45.                                         else if(i == 1)
  46.                                                 example2 = (Example_01) constructor.newInstance("7",5);
  47.                                        
  48.                                         //通过执行具有可变数量参数的构造方法创建对象
  49.                                         else{
  50.                                                 Object[] parameters = new Object[]{
  51.                                                                 new String[]{"100","200","300"}
  52.                                                 };
  53.                                                 example2 = (Example_01) constructor.newInstance(parameters);
  54.                                         }
  55.                                 }
  56.                                 catch(Exception e){
  57.                                         System.out.println("在创建对象时出现异常，下面执行setAccessible()方法");
  58.                                         //设置为允许访问
  59.                                         constructor.setAccessible(true);
  60.                                 }
  61.                         }
  62.                         
  63.                         example2.print();
  64.                         System.out.println();
  65.                         
  66.                 }

  68.         }

  70. }
复制代码
在没加while抛出异常这段的时候运行正常，
结果为：
查看是否允许带有可变数量的参数：false
该构造方法的入口参数类型依次为：
该构造方法可能抛出的异常类型为：
查看是否允许带有可变数量的参数：false
该构造方法的入口参数类型依次为：
class java.lang.String
int
该构造方法可能抛出的异常类型为：
查看是否允许带有可变数量的参数：true
该构造方法的入口参数类型依次为：
class [Ljava.lang.String;
该构造方法可能抛出的异常类型为：
class java.lang.NumberFormatException



加上while抛出异常并输出相应值得这段以后，
无限运行出现结果：在创建对象时出现异常，下面执行setAccessible()方法
搞晕了，求解释
作者: 禾呈    时间: 2013-7-19 14:42
此处当f(i == 2) 时 Constructor constructor = declaredConstructors；返回的constructor是不是无参的构造方法，所以执行 example2 = (Example_01) constructor.newInstance();时肯定出问题。

同理当 i=1，都是错的。



你可以这样写他们的判断方式
Example_01 example2 = null;
while(example2 == null){                           
     try{   
       if(parameterTypes.length==0){
            example2 = (Example_01) constructor.newInstance();
       }
            else if(parameterTypes.length==2){
          example2 = (Example_01) constructor.newInstance("7",5);
       }
       else{
          Object[] parameters = new Object[]{
                                new String[]{"100","200","300"}
                                 };
          example2 = (Example_01) constructor.newInstance(parameters.toString());
      }
   }

catch（）{}


作者: lkjghvcx@163.co    时间: 2013-7-19 15:18
本帖最后由 lkjghvcx@163.co 于 2013-7-19 15:54 编辑

         先调试一下：

                       Example_01 example2 = null;
                        while(example2 == null){
                                //如果该成员变量的访问权限为private，则抛出异常，即无法访问
                                constructor.setAccessible(true);     //放在前面，
                                try{
                                        //通过执行默认没有参数的构造方法创建对象
                                        if(i == 2)
                                                example2 = (Example_01) constructor.newInstance();

                                        //通过执行具有两个参数的构造方法创建对象
                                        else if(i == 1)
                                                example2 = (Example_01) constructor.newInstance("7",5);

                                        //通过执行具有可变数量参数的构造方法创建对象
                                        else{
                                                Object[] parameters = new Object[]{
                                                                new String[]{"100","200","300"}
                                                };
                                                example2 = (Example_01) constructor.newInstance(parameters);
                                        }
                                }
                                catch(Exception e){
//                                        System.out.println("在创建对象时出现异常，下面执行setAccessible()方法");
//                                        //设置为允许访问
//                                        constructor.setAccessible(true);
                                                e.printStackTrace();           //可以查看错误信息
                                }
                        }


错误信息：
java.lang.IllegalArgumentException              //参数错误
        at sun.reflect.GeneratedConstructorAccessor1.newInstance(Unknown Source)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
        at java.lang.reflect.Constructor.newInstance(Unknown Source)   
        at Reflect_Constructor.main(Reflect_Constructor.java:  )       example2 = (Example_01) constructor.newInstance(parameters);  这句出的错 //参数错误


考虑到 public Example_01(String...strings)throws NumberFormatException{  这个构造器可变参数是有问题的


因为private Example_01(){            
    }      私有的构造器
Example_01 example = new Example_01();  不可能这么调用的  new访问不到的private
所以new这句话调用的是public Example_01(String... strings)  构造器

在 public Example_01(String... strings)  构造器中
添加     System.out.println("开始调用构造器Example_01(String...  str)");
控制台会输出   开始调用构造器Example_01(String...  str)
所以new这句话调用的是public Example_01(String... strings)  构造器

为了让catch不无限循环 可以添加一句 System.exit(0);

是可变参数的问题；楼主改下试试                可变参数导致的混乱，












欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2