访问构造方法

package java反射;

import java.lang.reflect.Constructor;

/*
* 首先创建一个Example_01类，在该类中声明一个String型成员变量和3个int型成员变量，
* 并提供3个构造方法
*/
public class Example_01 {
   String s;
   int i,i2,i3;
   private Example_01(){

   }
   private Example_01(String s,int i) {
       this.s=s;
       this.i=i;
   }
   public Example_01(String...strings) throws NumberFormatException{
       if(0<strings.length) {
           i=Integer.valueOf(strings[0]);
       }
       if(1<strings.length) {
           i2=Integer.valueOf(strings[1]);
       }
       if(2<strings.length) {
           i3=Integer.valueOf(strings[2]);
       }
   }
   public void print() {
       System.out.println("s="+s);
       System.out.println("i="+i);
       System.out.println("i2="+i2);
       System.out.println("i3="+i3);
    }
}

package java反射;

import java.lang.reflect.Constructor;

/*
* 然后编写测试类Main_01，在该类中通过反射访问Example_01类中的所有构造方法，
* 并将该构造方法是否允许带有可变数量的参数，入口参数类型和可能抛出的异常类型信息输出到控制台。
*/
public class Main_01 {

   public static void main(String[] args) {
       Example_01 example = new Example_01("10", "20", "30");
       Class<? extends Example_01> exampleC = example.getClass();
       // 获得所有构造方法
       Constructor[] declaredConstructors = exampleC.getDeclaredConstructors();
       for (int i = 0; i < declaredConstructors.length; i++) {
           // 遍历构造方法
           Constructor constructor = declaredConstructors[i];
           System.out.println("查看是否带有可变数量的参数：" + constructor.isVarArgs());
           System.out.println("该构造方法的入口参数类型依次为：");
           // 获取所有参数类型
           Class[] parameterTypes = constructor.getParameterTypes();
           for (int j = 0; j < parameterTypes.length; j++) {
               System.out.println(" " + parameterTypes[j]);
           }
           System.out.println("该构造方法可能抛出的异常类型为：");
           // 获得所有可能抛出异常信息的类型
           Class[] exceptionTypes = constructor.getExceptionTypes();
           for (int j = 0; j < exceptionTypes.length; j++) {
               System.out.println(" " +exceptionTypes[j]);
           }
           Example_01 example2 = null;
           while (example2 == null) {
               try {//如果该成员变量的访问权限为private，则抛出异常，即不允许访问
                   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);//设置为允许访问
               }
           }

               example2.print();
               System.out.println();


       }
   }

}

运行结果

查看是否带有可变数量的参数：true
该构造方法的入口参数类型依次为：
class [Ljava.lang.String;
该构造方法可能抛出的异常类型为：
class java.lang.NumberFormatException
s=null
i=100
i2=200
i3=300

查看是否带有可变数量的参数：false
该构造方法的入口参数类型依次为：
class java.lang.String
int
该构造方法可能抛出的异常类型为：
在创建对象时抛出异常，下面执行setAccessible()方法
s=7
i=5
i2=0
i3=0

查看是否带有可变数量的参数：false
该构造方法的入口参数类型依次为：
该构造方法可能抛出的异常类型为：
在创建对象时抛出异常，下面执行setAccessible()方法
s=null
i=0
i2=0
i3=0

猜你喜欢