首页 > > 程序设计 > Java技术 >

java反射-使用反射获取类的所有信息

2019-05-17 00:02:32来源：博客园阅读 ()

在OOP(面向对象)语言中，最重要的一个概念就是：万事万物皆对象。

在java中，类也是一个对象，是java.lang.Class的实例对象，官网称该对象为类的类类型。

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

一个类的类类型有三种表示方式：

　　1.ClassName.class：类名.class，这种方式ying隐式的说明了任何一个类都有一个静态成员变量class。

　　2.obj.getClass()：通过实例对象.getClass()来获取该类的类类型。

　　3.Class.forName("xxx")：xxx表示类的全称，该方式代表动态加载类。

既然有了动态加载类，辣么肯定有静态加载类，辣么这两种是什么意思呢？

动态加载类：jvm运行时刻加载类。

静态加载类：编译时刻加载类，表示在编译时刻就需要加载所有的可能使用到的类。

　　简单举个栗子：使用new创建一个对象，我们在运行程序的时候，该对象的类必须存在，否则会产生编译错误，这种方式就是静态加载类。如果使用了Object obj = Class.forName("xxx")来创建实例，只有在运行时候，该类不存在时，才会抛出异常，这种方式就是动态加载类。

　　使用动态加载类，可以根据优雅的设计我们的代码，比如：

// 接口 A ，存在方法 print
// ClassB  实现了接口 A
// ClassC  实现了接口 A
// ClassD  实现了接口 A

// 通过动态加载，根据传入的类全称不同，创建不同的实例对象。调用方法 a，这执行对应实例的代码块
A a = Class.forName(classPakeage);
a.print();

下面我使用代码来获取一个类的基本信息:

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

/**
 * java反射 工具类
 */
public class ClassUtil {

    /**
     * 获取 obj 对象的所有信息，并打印 obj 类
　　　* 该方法中，getXXXXs()方法都表示获取此对象所有 public 类型
　　  * 对应的方法getDeclaredXXXs()方法表示获取该对象实现的所有对象(万事万物皆对象),不论访问权限
     * @param obj
     */
    public static void getClassMsg(Object obj){
        // 1.获取obj类的类类型
        Class c = obj.getClass();
        // 2.获取类 pageage
        Package pa = c.getPackage();
        System.out.println(pa.getName());
        // 3.获取类注释
        Annotation[] annotations = c.getAnnotations();
        for (Annotation annotation : annotations){
            System.out.println(annotation.toString());
        }
        System.out.print(c.getName() + " ");
        // 4.获取类的父类
        Class superClass = c.getSuperclass();
        if(superClass != null){
            System.out.print("extends " + superClass.getName());
        }
        // 5.获取类实现的接口
        Class[] interfaces = c.getInterfaces();
        if(interfaces.length != 0){
            System.out.print(" implements ");
            Class iface;
            for (int i = 0,len = interfaces.length; i < len; i++){
                iface = interfaces[i];
                System.out.print(iface.getName());
            }
        }
        System.out.println(" {");
        // 6.获取类的属性
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields){
            System.out.println(field.getName() + ";");
        }
        // 7.获取类的构造方法
        Constructor[] constructors = c.getDeclaredConstructors();
        for (Constructor constructor : constructors){
            System.out.print(constructor.getName() + "(");
            Class[] params = constructor.getParameterTypes();
            for (int i = 0,len = params.length; i < len; i++){
                System.out.print(params[i].getName());
                if(i != len - 1){
                    System.out.print(",");
                }
            }
            System.out.print(") {...}\n");
        }
        // 8.获取类的方法
        Method[] methods = c.getDeclaredMethods();
        for (Method mt : methods){
            System.out.print(mt.getName() + "(");
            Class[] params = mt.getParameterTypes();
            for (int i = 0,len = params.length; i < len; i++){
                System.out.print(params[i].getName());
                if(i != len - 1){
                    System.out.print(",");
                }
            }
            System.out.print(") {...}\n");
        }
        System.out.println("}");
    }
}