通过反射获取类的类名，方法和内部成员变量 

  1 package cn.lonecloud.reflect;
  2  
  3 import java.lang.reflect.Constructor;
  4 import java.lang.reflect.Field;
  5 import java.lang.reflect.Method;
  6  
  7 import org.junit.Test;
  8  
  9 public class ClassUtil {
 10     /**
 11      * 获取该类的信息
 12      * 比如他的类的类名和函数
 13      * @param obj
 14      */
 15     public static void getClassInfo(Object obj){
 16         //获取obj的类类型
 17         Class c1=obj.getClass();
 18         System.out.println("类的类型为"+c1.getName());
 19         System.out.println("类的类型为"+c1.getSimpleName());
 20         //获取类的类方法包括其父类的方法
 21         Method[] methods=c1.getMethods();
 22         System.out.println("该类的方法为");
 23         int c=0;
 24         for (int i = 0; i < methods.length; i++) {
 25             c++;
 26             Class returntype=methods[i].getReturnType();//获取该类的返回值
 27             System.out.print(returntype.getSimpleName()+" ");//打印返回值
 28             System.out.print(methods[i].getName()+"(");//打印方法名
 29             Class[] prams=methods[i].getParameterTypes();//获取参数的方法
 30             for (int j = 0; j < prams.length; j++) {
 31                 System.out.print(prams[j].getSimpleName()+"  ");//打印参数名
 32             }
 33             System.out.println(")");
 34         }
 35         System.out.println("利用getDeclaredMethods");
 36         //获取类的本类方法，不包含父类的方法可以获取他的类里面的所有方法
 37         Method[] methods1=c1.getDeclaredMethods();
 38         System.out.println("该类的方法为");
 39         int count=0;
 40         for (int i = 0; i < methods1.length; i++) {
 41             count++;
 42             Class returntype=methods1[i].getReturnType();//获取该类的返回值
 43             System.out.print(returntype.getSimpleName()+" ");//打印返回值
 44             System.out.print(methods1[i].getName()+"(");//打印方法名
 45             Class[] prams=methods1[i].getParameterTypes();//获取参数的方法
 46             for (int j = 0; j < prams.length; j++) {
 47                 System.out.print(prams[j].getSimpleName()+"  ");//打印参数名
 48             }
 49             System.out.println(")");
 50         }
 51         System.out.println(c+"  "+count);
 52     }
 53     /**
 54      * 获取构造方法
 55      * @param obj
 56      */
 57     public void getConMethod(Object obj){
 58         Class c=obj.getClass();
 59         //获取类的构造方法
 60         Constructor[] declaredConstructors = c.getDeclaredConstructors();
 61         for (Constructor constructor : declaredConstructors) {
 62             System.out.print(constructor.getName()+"(");
 63             Class[] parameterTypes = constructor.getParameterTypes();
 64             for (Class class1 : parameterTypes) {
 65                 System.out.print(class1.getName());
 66             }
 67         }
 68         System.out.println(")");
 69     }
 70     public void getClassFields(Object obj) {
 71         Class c=obj.getClass();
 72         //获取该类的成员变量
 73         Field[] declaredFields = c.getDeclaredFields();
 74         for (Field field : declaredFields) {
 75             //获取成员变量的类型
 76             System.out.print(field.getType().getName()+" ");
 77             //获取成员变量的名称
 78             System.out.println(field.getName());
 79         }
 80     }
 81     public void runClassMethod(Object obj) throws Exception{
 82         Class c1=obj.getClass();//获取类类型
 83         /*
 84          * c1.getDeclaredMethod("syso", parameterTypes)
 85          * 第一个是方法名，第二个为参数
 86          */
 87         Method m1=c1.getDeclaredMethod("de");
 88         m1.setAccessible(true);//设置这个方法的权限为public但是不会改变该方法的原有的权限
 89         /*
 90          * invoke(obj)对于指定的方法执行第一参数为这个对象，第二个为函数参数
 91          */
 92         System.out.println(m1.invoke(obj));
 93     }
 94     @Test
 95     public void test() throws Exception{
 96 //      String s="cewc";
 97 //      getClassInfo(s);
 98         word w=new word();
 99         getClassInfo(w);
100         getConMethod(w);
101         getClassFields(w);
102         runClassMethod(w);
103     }
104 }

 

package cn.lonecloud.reflect;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
 
import org.junit.Test;
 
public class ClassUtil {
    /**
     * 获取该类的信息
     * 比如他的类的类名和函数
     * @param obj
     */
    public static void getClassInfo(Object obj){
        //获取obj的类类型
        Class c1=obj.getClass();
        System.out.println("类的类型为"+c1.getName());
        System.out.println("类的类型为"+c1.getSimpleName());
        //获取类的类方法包括其父类的方法
        Method[] methods=c1.getMethods();
        System.out.println("该类的方法为");
        int c=0;
        for (int i = 0; i < methods.length; i++) {
            c++;
            Class returntype=methods[i].getReturnType();//获取该类的返回值
            System.out.print(returntype.getSimpleName()+" ");//打印返回值
            System.out.print(methods[i].getName()+"(");//打印方法名
            Class[] prams=methods[i].getParameterTypes();//获取参数的方法
            for (int j = 0; j < prams.length; j++) {
                System.out.print(prams[j].getSimpleName()+"  ");//打印参数名
            }
            System.out.println(")");
        }
        System.out.println("利用getDeclaredMethods");
        //获取类的本类方法，不包含父类的方法可以获取他的类里面的所有方法
        Method[] methods1=c1.getDeclaredMethods();
        System.out.println("该类的方法为");
        int count=0;
        for (int i = 0; i < methods1.length; i++) {
            count++;
            Class returntype=methods1[i].getReturnType();//获取该类的返回值
            System.out.print(returntype.getSimpleName()+" ");//打印返回值
            System.out.print(methods1[i].getName()+"(");//打印方法名
            Class[] prams=methods1[i].getParameterTypes();//获取参数的方法
            for (int j = 0; j < prams.length; j++) {
                System.out.print(prams[j].getSimpleName()+"  ");//打印参数名
            }
            System.out.println(")");
        }
        System.out.println(c+"  "+count);
    }
    /**
     * 获取构造方法
     * @param obj
     */
    public void getConMethod(Object obj){
        Class c=obj.getClass();
        //获取类的构造方法
        Constructor[] declaredConstructors = c.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructors) {
            System.out.print(constructor.getName()+"(");
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class class1 : parameterTypes) {
                System.out.print(class1.getName());
            }
        }
        System.out.println(")");
    }
    public void getClassFields(Object obj) {
        Class c=obj.getClass();
        //获取该类的成员变量
        Field[] declaredFields = c.getDeclaredFields();
        for (Field field : declaredFields) {
            //获取成员变量的类型
            System.out.print(field.getType().getName()+" ");
            //获取成员变量的名称
            System.out.println(field.getName());
        }
    }
    public void runClassMethod(Object obj) throws Exception{
        Class c1=obj.getClass();//获取类类型
        /*
         * c1.getDeclaredMethod("syso", parameterTypes)
         * 第一个是方法名，第二个为参数
         */
        Method m1=c1.getDeclaredMethod("de");
        m1.setAccessible(true);//设置这个方法的权限为public但是不会改变该方法的原有的权限
        /*
         * invoke(obj)对于指定的方法执行第一参数为这个对象，第二个为函数参数
         */
        System.out.println(m1.invoke(obj));
    }
    @Test
    public void test() throws Exception{
//      String s="cewc";
//      getClassInfo(s);
        word w=new word();
        getClassInfo(w);
        getConMethod(w);
        getClassFields(w);
        runClassMethod(w);
    }
}
posted @ 2021-11-22 14:19  正在努力的小白~  阅读(479)  评论(0)    收藏  举报