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

在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("}");
    }
}