[Java知识库]JAVA-反射

获取Class类对象

/*student是一个自定义类*/
public class main {
    public static void main(String[] args) throws ClassNotFoundException {
        /*方式一:通过类的属性获取类的对象*/
        Class<student> c=student.class;
        System.out.println(c);

        /*方式二:调用对象的getClass()方法 返回对象所属类对应的Class对象*/
        student s=new student();
        Class<? extends student> c2=s.getClass();
        System.out.println(c2);

        /*方式三:调用Class静态方法 forName(String classPath)*/
        Class c3=Class.forName("filemain.student");
        System.out.println(c3);

        /*方式四:使用类的加载器*/
        ClassLoader classLoader=main.class.getClassLoader();
        Class c4=classLoader.loadClass("filemain.student");
        System.out.println(c4);
    }
}

通过反射创建运行时类的对象

       Class cla=student.class;
       student obj=(student)cla.getDeclaredConstructor().newInstance();

获取运行时类属性

public class main {
    public static void main(String[] args) throws Exception{

        Class clazz=student.class;
        /*获取属性结构*/
        /*getFields()：获取当前运行时类及其父类中声明为public访问权限的属性*/
        Field[] fields=clazz.getFields();


        /*getDeclaredFields():获取当前运行时类自己的所有属性（不包含父类属性）*/
        Field[] declaredFields = clazz.getDeclaredFields();



        Class clazz1=student.class;
        Field[] declaredFields1 = clazz.getDeclaredFields();
        for(Field f:declaredFields1){
            //1、获取权限
            int modifiers = f.getModifiers();
            System.out.println(Modifier.toString(modifiers));

            //2、数据类型
            Class type=f.getType();
            System.out.println(type.getName());

            //3、变量名
            System.out.println(f.getName());

            System.out.println("=========");
        }
    }
}

获取运行时类的方法

public class main {
    public static void main(String[] args) throws Exception{

        Class clazz=student.class;

        /*getMethods()获取当前运行类及其父类中public方法*/
        Method[] method=clazz.getMethods();
        for(Method m:method){
            System.out.println(m);
        }

        /*getDeclaredMethods()获取当前运行时类中声明的所有方法(不包含父类中的方法)*/
        Method[] declaredMethods = clazz.getDeclaredMethods();

        /*获取注解*/
        for(Method m:declaredMethods){
            //获取注解
            Annotation[] annotation = m.getAnnotations();
            for(Annotation ann:annotation){
                System.out.println(ann);
            }
            
            //权限修饰符
            int modifiers = m.getModifiers();
            System.out.println(Modifier.toString(modifiers));

            //返回值类型
            System.out.println(m.getReturnType().getName());

            //方法名
            System.out.println(m.getName());

            //形参列表
            Class[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes==null&&parameterTypes.length==0)){
                for(int i=0;i< parameterTypes.length;i++){
                    if(i== parameterTypes.length-1){
                        System.out.println(parameterTypes[i].getName()+" arg_"+i);
                        break;
                    }
                    System.out.println(parameterTypes[i].getName()+" arg_"+i+",");
                }
            }

            //抛出异常
            Class[] exceptionTypes = m.getExceptionTypes();
            if(exceptionTypes.length>0){
                System.out.println("throws");
                for(int i=0;i<exceptionTypes.length;i++){
                    if(i==exceptionTypes.length-1){
                        System.out.println(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.println(exceptionTypes[i].getName()+",");
                }
            }

            System.out.println("========");
        }
    }
}
    

获取构造器

public class main {
    public static void main(String[] args) throws Exception{

        Class clazz=student.class;

        /*getConstructors()获取当前运行时类中声明为public的构造器*/
        Constructor[] constructors=clazz.getConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }

        /*getDeclaredConstructors()获取当前运行时类中所有的构造器*/
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c:declaredConstructors){
            System.out.println(c);
        }
    }
}    

获取带泛型父类的泛型

public class main {
    public static void main(String[] args) throws Exception{

        Class clazz=student.class;

        /*获取带泛型的父类的泛型*/
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType para=(ParameterizedType)genericSuperclass;
        //获取泛型类型
        Type[] actualtype= para.getActualTypeArguments();
        System.out.println(actualtype[0].getTypeName());

    }
}

获取运行时类的接口 、所在包、注解

public class main {
    public static void main(String[] args) throws Exception{

        Class clazz=student.class;

        Class[] interfaces = clazz.getInterfaces();
        for(Class c:interfaces){
            System.out.println(c);
        }

        /*获取运行时类所在的包*/
        Package aPackage = clazz.getPackage();

        /*获取运行时类的声明的注解*/
        Annotation[] annotations = clazz.getAnnotations();
        
    }
}

调用运行时类中指定的结构:属性

public class main {
    public static void main(String[] args) throws Exception {

        Class clazz = student.class;

        /*创建运行时类对象*/
        student obj = (student) clazz.getDeclaredConstructor().newInstance();

        /*获取指定的属性*/
        Field age = clazz.getDeclaredField("age");

        /*保证当前属性可以访问*/
        age.setAccessible(true);

        /*
        设置当前属性值
            set():参数1 指明设置的对象
                  参数2 参数属性值
         */
        age.set(obj, 101);


        /*
        获取当前属性值
            get():参数1 获取那个对象的当前属性值
        */
        System.out.println(age.get(obj));

    }
}

调用运行时类中指定的结构:方法

public class main {
    public static void main(String[] args) throws Exception {

        Class clazz = student.class;

        /*创建运行时类对象*/
        student obj = (student) clazz.getDeclaredConstructor().newInstance();

        /*
        获取指定的方法
            getDeclaredMethod():参数1 指明方法名称
                                参数2 形参列表
         */
        Method declared = clazz.getDeclaredMethod("setName", String.class);

        declared.setAccessible(true);

        /*
        invoke():参数1 方法的调用者
                 参数2 给方法形参赋值的实参
        invoke的返回值即为对应方法的返回值
        */
        Object returnobj = declared.invoke(obj, "abc");
        System.out.println((String) returnobj);

        /*调用静态方法*/
        Method show = clazz.getDeclaredMethod("show");
        show.setAccessible(true);
        Object reobn1=show.invoke(student.class);
        System.out.println(reobn1);

    }
}

调用运行时类中指定的结构:构造器

public class main {
    public static void main(String[] args) throws Exception {

        Class clazz = student.class;

        /*获取指定的构造器*/
        Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class);

        declaredConstructor.setAccessible(true);

        student tom =(student)declaredConstructor.newInstance("tom");
    }
}