反射基础练习

定义测试类

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

定义测试方法：

public static void main(String [] args){
    DemoOne demoOne=new DemoOne("10","20","30");
    Class<? extends DemoOne> demoC=demoOne.getClass();
    Constructor[] constructors=demoC.getDeclaredConstructors();

    for(int i=0;i<constructors.length;i++){
        Constructor<?> constructor=constructors[i];
        System.out.println("查看是否允许带有可变数量的参数："+constructor.isVarArgs());
        System.out.println("该构造参数方法入口参数类型依次为：");
        Class[] paramType=constructor.getParameterTypes();//可以获取所有参数类型
        for(int j=0;j<paramType.length;j++){
            System.out.println(" "+paramType[j]);
        }
        System.out.println("查看构造方法可以抛出的异常类型");
        Class[] exceptionTypes=constructor.getExceptionTypes();
        for(int j=0;j<exceptionTypes.length;j++){
            System.out.println(" " +exceptionTypes[j]);
        }
        DemoOne demoOne1=null;
        while(demoOne1==null){
            try {
                if(i==2)
                    //调用默认构造方法 因为构造方法为私有，所以抛出异常
                    demoOne1=(DemoOne)constructor.newInstance();
                else if(i==1){
                    demoOne1=(DemoOne)constructor.newInstance("7",5);
                }else{
                    //可变数量参数构造方法创建对象
                    Object[] parameters=new Object[]{new String[]{"100","200","300"}};
                    demoOne1=(DemoOne)constructor.newInstance(parameters);
                }
            }catch (Exception e){
                System.out.println("创建对象抛出异常");
                //使用了私有的构造方法，所以设置构造器为可以访问再次循环达到可以正常运行
                constructor.setAccessible(true);
            }

        }
        if(demoOne1!=null){
            demoOne1.print();
            System.out.println("");
        }

    }
}

运行结果：

查看是否允许带有可变数量的参数：true

该构造参数方法入口参数类型依次为：

class [Ljava.lang.String;

查看构造方法可以抛出的异常类型

class java.lang.NumberFormatException

s=null

i=100

i1=200

i2=300

查看是否允许带有可变数量的参数：false

该构造参数方法入口参数类型依次为：

class java.lang.String

int

查看构造方法可以抛出的异常类型

s=7

i=5

i1=0

i2=0

查看是否允许带有可变数量的参数：false

该构造参数方法入口参数类型依次为：

查看构造方法可以抛出的异常类型

创建对象抛出异常

s=null

i=0

i1=0

i2=0

注：String... strings 定义可变数量的参数

API详解：

public class RefelectTest {

    private  String name;

    public RefelectTest() {
        System.out.println("constructor");
    }
    public RefelectTest(String param,String param2) {
        System.out.println("constructor");
    }

    public boolean  methodOne(){
        System.out.println("methodOne");
        return true;
    }
    public void methodTwo(String param){
        System.out.println("methodTwo");
    }

    public static void main (String [] args){
        RefelectTest refelectTest=new RefelectTest();

        Class testC=refelectTest.getClass();
        System.out.println(testC.getPackage()); //获得该类的存放路径
        System.out.println(testC.getName());//获得该类的名字

        Class supper=testC.getSuperclass(); //获得父类
        Class[] interfaces=testC.getInterfaces(); //获取该类实现的所有接口
        Constructor [] constructors =testC.getConstructors(); //获取权限为public的所有构造方法
        Class[] classes=new Class[]{String.class,String.class};
        try {
            Constructor constructor=testC.getConstructor(classes);//获取指定的构造方法
            Constructor constructor1=testC.getDeclaredConstructor(classes);//获取指定的构造方法
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        Constructor[] constructors1=testC.getDeclaredConstructors();//获取所有构造方法，按照声明顺序


        Method[] methods=testC.getMethods();  //获得方法数组
        try {
            Method method=testC.getMethod("methodTwo",new Class[]{String.class});//获得指定的方法
            Method method3=testC.getDeclaredMethod("methodTwo",new Class[]{String.class});//获得指定方法

        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        Method[] methods1=testC.getDeclaredMethods();//获得所有方法按照声明顺序


        Field [] fields=testC.getFields();//获取权限为public的成员变量
        Field [] fields1=testC.getDeclaredFields();//获得所有成员变量按声明顺序
        try {
            Field field=testC.getField("name");//获取指定的成员
            Field field1=testC.getDeclaredField("name");//获取还制定的成员变量
        }catch (Exception e){

        }

        Class [] classes1=testC.getClasses();//获取权限为public 的内部类
        Class [] classes2=testC.getDeclaredClasses();//获取全部的内部类

        Class ClassIn=testC.getDeclaringClass();//如果该类为内部类则获取他的成员类

    }
}