反射基础操作

   
    

    
    @Test
    public void getClazz() throws ClassNotFoundException {
        System.out.println(1/1);
        //练习获取字节码对象的三种方式
        Class clazz = Class.forName("cn.tedu.reflection.Student");
        Class clazz1 = Student.class;
        Class clazz2 = new Student().getClass();
        //直接打印字节码对象，注意前面有个class，这是对象
        System.out.println(clazz);//class cn.tedu.reflection.Student 对象
        //通过字节码对象获得的目标类Student的全路径名
        System.out.println(clazz.getName());//cn.tedu.reflection.Student
        //通过字节码对象获取目标类的类名
        System.out.println(clazz1.getSimpleName());//Student
        //通过字节码对象获取目标类的包对象
        System.out.println(clazz2.getPackage());//package cn.tedu.reflection
        //先通过字节码对象获取目标类的包对象，再通过包对象获取包名
        System.out.println(clazz2.getPackage().getName());//cn.tedu.reflection
    }

    @Test
    public void getFie() throws ClassNotFoundException {
        //获取字节码对象
        Class clazz = Class.forName("cn.tedu.reflection.Student");
        //通过字节码对象获取目标类中成员变量们
        Field[] fs = clazz.getFields();
        
        //遍历数组，获取每个字段对象，并进行进一步操作
        System.out.println(Arrays.toString(fs));//这个只是测试看一看
        for (Field f:fs){
            //通过本轮循环到的字段对象，进一步获取字段的名字与字段的类型
            System.out.println(f.getName());
            System.out.println(f.getType());
        }

    }

  
    @Test
    public void getStu(){
        //创建Student类对象的3个对象
        Student s1 = new Student("李槐", 21);
        Student s2 = new Student("李宝瓶",22);
        Student s3 = new Student("林守一",28);
        Student[] s = {s1,s2,s3};
        //直接打印查看数组中的所有元素,可以重写toString看文字
        System.out.println(Arrays.toString(s));//只能看一看.
        //遍历数组，拿到每一个学生对象进一步操作
        for (Student st:s){
            System.out.println(st);//直接打印本轮循环到的学生对象
            st.play();//通过本轮循环到的学生对象调用学生的play
            System.out.println(st.age);//通过本轮循环到的学生对象查看属性值
        }

    @Test
    public void getFuction(){
        //获取字节码对象
        Class clazz = Student.class;
        //通过字节码对象获取目标类中的成员方法们
        Method[] ms = clazz.getMethods();
        //通过高效for循环遍历数组，拿到每一个方法对象，做进一步操作
        for (Method mt:ms){
            System.out.println(mt);//查看循环获取到的每个方法对象
            System.out.println(mt.getName());//通过方法对象，获取当前的方法名
            Class[] pt = mt.getParameterTypes();//通过方法对象获取当前方法的参数类型
            System.out.println(Arrays.toString(pt));
        }
    }

    @Test
    public void getCons(){
        //获取字节码对象
        Class clazz = new Student().getClass();
        //通过字节码对象，获取目标类中的构造方法们
        Constructor[] cs = clazz.getConstructors();
        //遍历构造函数数组，获取每一个构造函数对象，做进一步操作
        for(Constructor ct:cs){
            System.out.println(ct);
            System.out.println(ct.getName());//通过遍历到的构造函数对象，获取构造函数名
            Class[] pt = ct.getParameterTypes();//通过遍历到的构造函数对象，获取构造函数的参数类型
            System.out.println(Arrays.toString(pt));
        }
    }

 
    @Test
    public void getObject() throws Exception{
        //获取字节码对象
        Class clazz = Student.class;
        //通过字节码对象，创建目标类的对象，注意抛出异常
        
        Object o = clazz.newInstance();
        //这一步已经通过无参构造创建好了对象：Student{name='null', age=0}
        System.out.println(o);

        
        //获取目标类中指定的全参构造
        Constructor c = clazz.getConstructor(String.class,int.class);
        //通过刚刚获取到的构造函数对象来创建目标类的对象
        Object o1 = c.newInstance("赵六",7);
        System.out.println(o1);
    }

    public void getOBject() throws Exception {
        Class clazz = Student.class;
        Constructor c = clazz.getConstructor(String.class);
        Object o3 = c.newInstance("魏桀");
        System.out.println(o3);
    }