java 反射简介

---

java 反射简介

 

反射：根据类的class对象对类进行相关操作

 

 

**************************

相关类及接口

 

class：类对象

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement,
                              TypeDescriptor.OfField<Class<?>>,
                              Constable {

*********
常用方法

    public static Class<?> forName(String className)       //根据className构造类对象
    public static Class<?> forName(String name, boolean initialize, ClassLoader loader)                         

    public native boolean isAssignableFrom(Class<?> cls);  //是否继承子cls类
    public native boolean isInterface();                   //判断类对象是否是接口
    public native boolean isArray();                       //类对象是否是数组
    public native boolean isPrimitive();                   //类对象是否是基本数据类型
    public boolean isAnnotation() {                        //类对象是否是注释
    public boolean isEnum() {                              //类对象是否是枚举

    public Package getPackage() {                          //获取包对象
    public String getPackageName() {                       //获取包名称
    public String getName() {                              //获取类的全限定名
    public ClassLoader getClassLoader() {                  //获取类的类加载器

    public native Class<? super T> getSuperclass();        //获取父类，父类如果是泛型，不能获得泛型类型
    public Type getGenericSuperclass() {                   //获取父类，如果父类有泛型，可获得泛型类型

    public Class<?>[] getClasses() {                       //获得父类所有的内部类
    public Class<?>[] getDeclaredClasses() throws SecurityException { //获取类中的内部类，不包含构造方法、普通方法中定义的内部类

    public Class<?> getDeclaringClass() throws SecurityException { //根据内部类的class对象获得外部类的class对象，内部类如果是在外部类中直接定义的，可获得外部类的名称，如果是在构造方法、普通方法中定义的，则返回null
    public Class<?> getEnclosingClass() throws SecurityException { //根据内部类的class对象获得外部类的class对象，内部类在类中直接定义、在构造方法、普通方法定义，均可获得外部类的名称

    public Class<?>[] getInterfaces() {     //获取类实现的接口
    private Class<?>[] getInterfaces(boolean cloneArray) {
    public Type[] getGenericInterfaces() {

    public native int getModifiers();       //获取类的修饰符
    public native Object[] getSigners();    //返回类的签名，没有则返回null

    public String getSimpleName() {         //返回类的名称，不包含包的名称
    public String getTypeName() {           //返回类的名称，包含包的名称


*********
构造方法相关操作

    public Constructor<?>[] getConstructors() throws SecurityException {
    public Constructor<T> getConstructor(Class<?>... parameterTypes)
                          //父类构造函数

    public Constructor<?>[] getDeclaredConstructors() throws SecurityException {
    public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
                          //本类构造函数

    public Constructor<?> getEnclosingConstructor() throws SecurityException {
                          //根据内部类的class对象获得定义内部类的构造方法


*********
字段相关操作

    public Field getField(String name)                     //父类字段
    public Field[] getFields() throws SecurityException { 

    public Field getDeclaredField(String name)             //本类字段
    public Field[] getDeclaredFields() throws SecurityException { 


*********
普通方法相关操作

    public Method[] getMethods() throws SecurityException {
    public Method getMethod(String name, Class<?>... parameterTypes)
                          //可获得本类及父类普通方法

    public Method[] getDeclaredMethods() throws SecurityException {
    public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
    List<Method> getDeclaredPublicMethods(String name, Class<?>... parameterTypes) {
                          //本类普通方法

    public Method getEnclosingMethod() throws SecurityException {
    private EnclosingMethodInfo getEnclosingMethodInfo() {
                         //根据内部类的class对象获得定义内部类的普通方法信息


*********
注解相关操作

    public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) { //指定的注解是否存在
                    
    public Annotation[] getAnnotations() {            //获取父类注解
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
    public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass) {                   

    public Annotation[] getDeclaredAnnotations()  {    //获取本类注解
    public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass) {
    Map<Class<? extends Annotation>, Annotation> getDeclaredAnnotationMap() {
    public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass) {                 

    public AnnotatedType getAnnotatedSuperclass() {
    public AnnotatedType[] getAnnotatedInterfaces() {


*********
数组相关操作

    public Class<?> getComponentType() {    //获取数组的对象类型
    public Class<?> componentType() {
    public Class<?> arrayType() {

 

constructor：构造函数操作

public final class Constructor<T> extends Executable {

********
常用方法

    public void setAccessible(boolean flag) {  //使构造方法可访问
    public Class<T> getDeclaringClass() {      //获得定义构造方法的类对象
    public String getName() {                  //获得构造方法的名称

    public int getModifiers() {  //获得方法的修饰符

    public TypeVariable<Constructor<T>>[] getTypeParameters() {
                                 //获得构造方法的参数类型，包含泛型类型
    Class<?>[] getSharedParameterTypes() { return parameterTypes; }
    public Class<?>[] getParameterTypes() { return parameterTypes.clone(); }

    public int getParameterCount() { return parameterTypes.length; }
                  //获得参数的个数

    public Type[] getGenericParameterTypes() {  //获得泛型参数类型

    public Class<?>[] getExceptionTypes() { return exceptionTypes.clone(); }
    Class<?>[] getSharedExceptionTypes() { return exceptionTypes; }
    public Type[] getGenericExceptionTypes() { return super.getGenericExceptionTypes(); }

    public T newInstance(Object ... initargs)  throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
                          //构造实例对象

    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
    public Annotation[] getDeclaredAnnotations()  {
    public Annotation[][] getParameterAnnotations() {
                         //获得注解

********
转换为字符串

    public String toString() {
        return sharedToString(Modifier.constructorModifiers(),
                              false,
                              parameterTypes,
                              exceptionTypes);
    }

    String toShortString() {
        StringBuilder sb = new StringBuilder("constructor ");
        sb.append(getDeclaringClass().getTypeName());
        sb.append('(');
        StringJoiner sj = new StringJoiner(",");
        for (Class<?> parameterType : getParameterTypes()) {
            sj.add(parameterType.getTypeName());
        }
        sb.append(sj);
        sb.append(')');
        return sb.toString();
    }

    public String toGenericString() {
        return sharedToGenericString(Modifier.constructorModifiers(), false);
    }

 

field：字段操作

public final class Field extends AccessibleObject implements Member {

********
常用方法

    public void setAccessible(boolean flag) {  //设置字段可被访问
    public Class<?> getDeclaringClass() {      //返回定义字段的类

    public int getModifiers() {                //返回字段的修饰符
    public Class<?> getType() {                //返回字段的类型
    public Type getGenericType() {             //返回字段类型，泛型返回泛型的数据类型
    public String getName() {                  //返回字段的名称

    public boolean isEnumConstant() {          //字段是否是枚举常量


********
获取字段的值

    public Object get(Object obj)         
    public boolean getBoolean(Object obj)
    public byte getByte(Object obj)
    public char getChar(Object obj)
    public short getShort(Object obj)
    public int getInt(Object obj)
    public long getLong(Object obj)
    public float getFloat(Object obj)
    public double getDouble(Object obj)


********
设置字段的值

    public void set(Object obj, Object value)
    public void setBoolean(Object obj, boolean z)
    public void setByte(Object obj, byte b)
    public void setChar(Object obj, char c)
    public void setShort(Object obj, short s)
    public void setInt(Object obj, int i)
    public void setLong(Object obj, long l)
    public void setFloat(Object obj, float f)
    public void setDouble(Object obj, double d)


********
获取字段上的注解

    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
    public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
    public Annotation[] getDeclaredAnnotations()  {
    public AnnotatedType getAnnotatedType() {


********
将字段转换为字符串

    public String toString() {
        int mod = getModifiers();
        return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            + getType().getTypeName() + " "
            + getDeclaringClass().getTypeName() + "."
            + getName());
    }

    @Override
    String toShortString() {
        return "field " + getDeclaringClass().getTypeName() + "." + getName();
    }

    public String toGenericString() {
        int mod = getModifiers();
        Type fieldType = getGenericType();
        return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            + fieldType.getTypeName() + " "
            + getDeclaringClass().getTypeName() + "."
            + getName());
    }

 

method：方法操作

public final class Method extends Executable {

********
常用方法

    public void setAccessible(boolean flag) {            //设置方法可访问
    public Class<?> getDeclaringClass() {                //获得定义该方法的类或者接口

    public String getName() {                            //获得方法的名称
    public int getModifiers() {                          //获得方法的修饰符
    public TypeVariable<Method>[] getTypeParameters() {  //获得泛型方法的数据类型
    public Class<?> getReturnType() {                    //获得方法的返回类型
    public Type getGenericReturnType() {                 //活的方法的返回类型，包含泛型

    public Object invoke(Object obj, Object... args) {   //方法调用
    public boolean isDefault() {                         //方法是否是默认方法
    public Object getDefaultValue() {                    //获得default方法的默认值


********
方法体的参数类型

    public Class<?>[] getParameterTypes() { return parameterTypes.clone(); }
    Class<?>[] getSharedParameterTypes() { return parameterTypes; }
    public Type[] getGenericParameterTypes() { return super.getGenericParameterTypes(); }

    public int getParameterCount() { return parameterTypes.length; }
                    //获得方法体的参数个数


********
方法体的异常类型

    public Class<?>[] getExceptionTypes() { return exceptionTypes.clone(); }
    Class<?>[] getSharedExceptionTypes() { return exceptionTypes; }
    public Type[] getGenericExceptionTypes() { return super.getGenericExceptionTypes(); }


********
获得方法上的注解

    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
    public Annotation[] getDeclaredAnnotations()  { 
    public Annotation[][] getParameterAnnotations() {
    public AnnotatedType getAnnotatedReturnType() {


********
method转换为字符串

    public String toString() {
        return sharedToString(Modifier.methodModifiers(),
                              isDefault(),
                              parameterTypes,
                              exceptionTypes);
    }//返回修饰符 是否默认方法 参数体类型 异常体类型

    void specificToStringHeader(StringBuilder sb) {
        sb.append(getReturnType().getTypeName()).append(' ');
        sb.append(getDeclaringClass().getTypeName()).append('.');
        sb.append(getName());
    }//返回类型 类名+方法名

    String toShortString() {
        StringBuilder sb = new StringBuilder("method ");
        sb.append(getDeclaringClass().getTypeName()).append('.');
        sb.append(getName());
        sb.append('(');
        StringJoiner sj = new StringJoiner(",");
        for (Class<?> parameterType : getParameterTypes()) {
            sj.add(parameterType.getTypeName());
        }
        sb.append(sj);
        sb.append(')');
        return sb.toString();
    }//返回method 类名+方法名 参数体类型

    public String toGenericString() {
        return sharedToGenericString(Modifier.methodModifiers(), isDefault());
    }

    void specificToGenericStringHeader(StringBuilder sb) {
        Type genRetType = getGenericReturnType();
        sb.append(genRetType.getTypeName()).append(' ');
        sb.append(getDeclaringClass().getTypeName()).append('.');
        sb.append(getName());
    }

 

modifier：修饰符

public class Modifier {

********
字段属性

    public static final int PUBLIC           = 0x00000001;
    public static final int PRIVATE          = 0x00000002;
    public static final int PROTECTED        = 0x00000004;
    public static final int STATIC           = 0x00000008;
    public static final int FINAL            = 0x00000010;
    public static final int SYNCHRONIZED     = 0x00000020;
    public static final int VOLATILE         = 0x00000040;
    public static final int TRANSIENT        = 0x00000080;
    public static final int NATIVE           = 0x00000100;
    public static final int INTERFACE        = 0x00000200;
    public static final int ABSTRACT         = 0x00000400;
    public static final int STRICT           = 0x00000800;


********
常用方法

    public static String toString(int mod) {
        StringJoiner sj = new StringJoiner(" ");

        if ((mod & PUBLIC) != 0)        sj.add("public");
        if ((mod & PROTECTED) != 0)     sj.add("protected");
        if ((mod & PRIVATE) != 0)       sj.add("private");

        /* Canonical order */
        if ((mod & ABSTRACT) != 0)      sj.add("abstract");
        if ((mod & STATIC) != 0)        sj.add("static");
        if ((mod & FINAL) != 0)         sj.add("final");
        if ((mod & TRANSIENT) != 0)     sj.add("transient");
        if ((mod & VOLATILE) != 0)      sj.add("volatile");
        if ((mod & SYNCHRONIZED) != 0)  sj.add("synchronized");
        if ((mod & NATIVE) != 0)        sj.add("native");
        if ((mod & STRICT) != 0)        sj.add("strictfp");
        if ((mod & INTERFACE) != 0)     sj.add("interface");

        return sj.toString();
    }