通过反射获取类的完整结构

通过反射获取类的完整结构

获取属性的各个部分的内容：权限修饰符 变量类型 变量名等

获取运行时类的方法
注 解 ，权限修饰符， 返回值类型 ，方法名， 形参列表， 异常等

TestConstructor

package com.aff.reflection;
import org.junit.Test;
public class TestConstructor {
    @Test
    public void test1() throws Exception {
        Class clazz = Person.class;
        /*创建对应的运行时类的对象，使用newInstance(),实际上就是调用了运行时类的空参的构造器
          想要能够创建成功：①要求对应的运行时类要有空参的构造器
                         ②构造器的权限修饰符的权限要足够
        */
        Object obj = clazz.newInstance();
        Person p = (Person) obj;
        System.out.println(p);//Person [name=null, age=0]
    }
}

TestField

package com.aff.reflection;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

public class TestField {
    @Test
    public void test1() {
        Class clazz = Person.class;
        // getFields() :只能获取到运行时类中及其父类中声明为public的属性
        Field[] fields1 = clazz.getFields();
        System.out.println(fields1);
        System.out.println();

        // 2.getDeclaredFields():获取运行时类本身声明的所有的属性
        Field[] fields2 = clazz.getDeclaredFields();
        for (Field f : fields2) {
            System.out.println(fields2);
        }
    }

    // 权限修饰符 变量类型 变量名
    // 获取属性的各个部分的内容
    @Test
    public void test2() {
        Class clazz = Person.class;
        Field[] fields2 = clazz.getDeclaredFields();
        for (Field f : fields2) {
            // 1.获取每个属性的权限修饰符
            int i = f.getModifiers();
            String str = Modifier.toString(i);
            System.out.println(str);

            // 2.获取属性的变量类型
            Class type = f.getType();
            System.out.println(type.getName() + "");

            // 3.获取属性名
            System.out.println(f.getName());
            System.out.println();
        }
    }

    // 获取运行时类的方法
    // 注解，权限修饰符， 返回值类型 ，方法名， 形参列表， 异常
    @Test
    public void test3() {
        Class clazz = Person.class;
        // 1.getMethods(): 获取运行时类及其父类的所有的声明为public的方法
        Method[] m1 = clazz.getMethods();
        for (Method m : m1) {
            System.out.println(m);
        }
        System.out.println("----------------------");

        // getDeclaredMethods():获取运行时类本身声明的所有的方法
        Method[] m2 = clazz.getDeclaredMethods();
        for (Method m : m2) {
            // 1.注解
            Annotation[] ann = m.getAnnotations();
            for (Annotation a : ann) {
                System.out.println(a + "--");
            }

            // 2.权限修饰符
            String str = Modifier.toString(m.getModifiers());
            System.out.print(str + "--");

            // 3.返回值类型
            Class returnType = m.getReturnType();
            System.out.print(returnType.getName() + "--");

            // 4.方法名
            System.out.print(m.getName() + "--");

            // 5.形参列表
            // System.out.print("(");
            Class[] param = m.getParameterTypes();
            for (int i = 0; i < param.length; i++) {
                System.out.print("(" + param[i].getName() + " args-" + i + ")");
            }
            // 6.异常类型
            Class[] exps = m.getExceptionTypes();
            if (exps.length != 0) {
                System.out.println("throws");
            }
            for (int i = 0; i < exps.length; i++) {
                System.out.print(exps[i].getName() + "--");
            }
            System.out.println();
        }
    }
}