java反射總結(jié)

所用到的類

  • java.lang.Class
  • java.lang.reflect.Constructor
  • java.lang.reflect.Field
  • java.lang.reflect.Method
  • java.lang.reflect.Modifier

作用：

  • 當(dāng)一個(gè)類被加載以后，Java虛擬機(jī)就會(huì)自動(dòng)產(chǎn)生一個(gè)Class對(duì)象。通過這個(gè)Class對(duì)象我們就能獲得加載到虛擬機(jī)當(dāng)中這個(gè)Class對(duì)象對(duì)應(yīng)的方法、成員以及構(gòu)造方法的聲明和定義等信息。

Class相關(guān)

三種獲取Class對(duì)象的方法

可以根據(jù)類的狀態(tài)使用不同的方法

public class MyClass {  
}

方式一：

Class<?> clazz = MyClass.class;

方式二：

Class<?> clazz = null;  
try {  
    clazz = Class.forName("com.xx.cn.MyClass");//當(dāng)類沒有加載到內(nèi)存可使用這種方式
} catch (ClassNotFoundException e) {  
    e.printStackTrace();  
}

方式三：

MyClass myClass = new MyClass();  
Class<?> clazz = myClass.getClass();

獲取父類

public Class<? super T> getSuperclass();

獲取內(nèi)部類

/** 
 * 獲取類中本身定義的公共、私有、保護(hù)的內(nèi)部類 
 */  
public Class<?>[] getDeclaredClasses();  
  
/** 
 * 獲取類本身和其父類定義的公共、私有、保護(hù)的內(nèi)部類 
 */  
public Class<?>[] getClasses();

獲取定義它的外部類

/** 
 * 獲取定義它的外部類，如果為匿名內(nèi)部類則返回null 
 */  
public Class<?> getDeclaringClass();  
  
/** 
 * 獲取定義它的外部類，匿名內(nèi)部類同樣有效 
 */  
public Class<?> getEnclosingClass();

Field相關(guān)

通過Class獲取Field

/** 
 * 獲取類本身的所有字段，包括公有、保護(hù)、私有 
 */  
public native Field[] getDeclaredFields();  
/** 
 * 獲取類本身和其所有父類的公有和保護(hù)字段 
 */  
public Field[] getFields();  
/** 
 * 獲取類本身的指定字段，包括公有、保護(hù)、私有 
 * @param name  字段名 
 */  
public native Field getDeclaredField(String name) throws NoSuchFieldException;  
/** 
 * 獲取類本身和其所有父類指定的公有和保護(hù)字段 
 * @param name  字段名 
 */  
public Field getField(String name) throws NoSuchFieldException;

Field的相關(guān)屬性

/** 
 * 獲取字段的作用域：public、protected、private、abstract、static、final ... 
 */  
Modifier.toString(field.getModifiers());  
/** 
 * 獲取字段的類型，配合getSimpleName()使用：int、long、String ... 
 */  
field.getType().getSimpleName();  
/** 
 * 獲取字段名稱 
 */  
field.getName();

對(duì)Field設(shè)置值

public native Object get(Object object) throws IllegalAccessException, IllegalArgumentException;
public native boolean getBoolean(Object object) throws IllegalAccessException, IllegalArgumentException;
public native byte getByte(Object object) throws IllegalAccessException, IllegalArgumentException;
public native char getChar(Object object) throws IllegalAccessException, IllegalArgumentException;
public native double getDouble(Object object) throws IllegalAccessException, IllegalArgumentException;
public native float getFloat(Object object) throws IllegalAccessException, IllegalArgumentException;
public native int getInt(Object object) throws IllegalAccessException, IllegalArgumentException;
public native long getLong(Object object) throws IllegalAccessException, IllegalArgumentException;
public native short getShort(Object object) throws IllegalAccessException, IllegalArgumentException;
public native void set(Object object, Object value) throws IllegalAccessException, IllegalArgumentException;
public native void setBoolean(Object object, boolean value) throws IllegalAccessException, IllegalArgumentException;
public native void setByte(Object object, byte value) throws IllegalAccessException, IllegalArgumentException;
public native void setChar(Object object, char value) throws IllegalAccessException, IllegalArgumentException;
public native void setDouble(Object object, double value) throws IllegalAccessException, IllegalArgumentException;
public native void setFloat(Object object, float value) throws IllegalAccessException, IllegalArgumentException;
public native void setInt(Object object, int value) throws IllegalAccessException, IllegalArgumentException;
public native void setLong(Object object, long value) throws IllegalAccessException, IllegalArgumentException;
public native void setShort(Object object, short value) throws IllegalAccessException, IllegalArgumentException;
    1. 每個(gè)方法里頭都有一個(gè)Object參數(shù)，對(duì)于非靜態(tài)字段來說，它必須設(shè)置為具體的實(shí)例，而對(duì)于靜態(tài)字段來說它沒有實(shí)際意義，可設(shè)為null；
    1. 對(duì)于私有(private)字段，在進(jìn)行訪問的時(shí)候需要先調(diào)用 field.setAccessible(true)，而公有、保護(hù)字段可直接進(jìn)行訪問；
其實(shí)聯(lián)系下我們平時(shí)對(duì)訪問權(quán)限的控制還是很好理解的，靜態(tài)變量和具體實(shí)例無關(guān)，私有變量外部不能訪問。

使用方式：

MyClass myClass = new MyClass();  
Class<?> cls = myClass.getClass();  
// 獲取私有域  
Field field = cls.getDeclaredField("myPrivateInt");  
  
// 如果為靜態(tài)變量可按以下調(diào)用  
field.setAccessible(true);  
field.getInt(null);  
field.setInt(null, 33);  
  
// 如果為非靜態(tài)變量則必須按以下調(diào)用  
field.setAccessible(true);  
field.getInt(myClass);  
field.setInt(myClass, 33);

Method相關(guān)

通過Class獲取Method

/** 
 * 獲取類本身的所有方法，包括公有、保護(hù)、私有 
 */  
public Method[] getDeclaredMethods();  
/** 
 * 獲取類本身和其所有父類的公有和保護(hù)方法 
 */  
public Method[] getMethods();  
/** 
 * 獲取類本身的指定方法，包括公有、保護(hù)、私有 
 * @param name  方法名 
 * @param parameterTypes    參數(shù)類型 
 */  
public Method getDeclaredMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException;  
/** 
 * 獲取類本身和其所有父類指定的公有和保護(hù)方法 
 * @param name  方法名 
 * @param parameterTypes    參數(shù)類型 
 */  
public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException;

通過Class獲取構(gòu)造方法

/** 
 * 獲取類本身的所有構(gòu)造方法，包括公有、保護(hù)、私有 
 */  
public Constructor<?>[] getDeclaredConstructors();  
/** 
 * 獲取類本身非私有構(gòu)造方法 
 */  
public Constructor<?>[] getConstructors();  
/** 
 * 獲取類本身指定的構(gòu)造方法 
 * @param parameterTypes    參數(shù)類型 
 */  
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException;  
/** 
 * 獲取類本身指定的非私有構(gòu)造方法 
 * @param parameterTypes    參數(shù)類型 
 */  
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException;

Method的常用屬性，構(gòu)造方法沒有返回值屬性

/** 
 * 獲取方法的作用域：public、protected、private、abstract、static、final ... 
 */  
Modifier.toString(method.getModifiers());  
/** 
 * 獲取方法的返回值類型，配合getSimpleName()使用：int、long、String ... 
 */  
method.getReturnType().getSimpleName();  
/** 
 * 獲取方法名稱 
 */  
method.getName();  
/** 
 * 獲取方法參數(shù) 
 */  
Class<?>[] parameterTypes = method.getParameterTypes();  
/** 
 * 獲取方法聲明所在類 
 */  
method.getDeclaringClass();

執(zhí)行方法

/** 
 * 執(zhí)行方法 
 */  
public native Object invoke(Object receiver, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;  
/** 
 * 執(zhí)行構(gòu)造方法 
 */  
public native T newInstance(Object... args) throws InstantiationException,IllegalAccessException, IllegalArgumentException, InvocationTargetException;

static內(nèi)部類和非static內(nèi)部類區(qū)別

public class ExampleUnitTest {
    @Test
    public void testDumpClassInfo() throws Exception {
        /**
         * ------ Constructor ------>
         private com.example.administrator.mydemo.utils.Outer$Inner(com.example.administrator.mydemo.utils.Outer)
         private com.example.administrator.mydemo.utils.Outer$Inner(com.example.administrator.mydemo.utils.Outer,java.lang.String)
         ------ Field ------>
         private java.lang.String com.example.administrator.mydemo.utils.Outer$Inner.innerField
         final com.example.administrator.mydemo.utils.Outer com.example.administrator.mydemo.utils.Outer$Inner.this$0
         ------ Method ------>
         private void com.example.administrator.mydemo.utils.Outer$Inner.innerMethod()
         */
        String Inner_classInfo = dumpClass("com.example.administrator.mydemo.utils.Outer$Inner");
        System.out.print(Inner_classInfo);

        /**
         * ------ Constructor ------>
         private com.example.administrator.mydemo.utils.Outer$StaticInner()
         private com.example.administrator.mydemo.utils.Outer$StaticInner(java.lang.String)
         ------ Field ------>
         private java.lang.String com.example.administrator.mydemo.utils.Outer$StaticInner.innerField
         private static java.lang.String com.example.administrator.mydemo.utils.Outer$StaticInner.innerStaticField
         ------ Method ------>
         private void com.example.administrator.mydemo.utils.Outer$StaticInner.innerMethod()
         private static void com.example.administrator.mydemo.utils.Outer$StaticInner.innerStaticMethod()
         */

        String StaticInner_classInfo = dumpClass("com.example.administrator.mydemo.utils.Outer$StaticInner");
        System.out.print(StaticInner_classInfo);


    }

    /**
     * 獲取類的所有 構(gòu)造函數(shù)，屬性，方法
     *
     * @param className 類名
     * @return
     */
    public static String dumpClass(String className) {
        StringBuffer sb = new StringBuffer();
        Class<?> clazz;
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return "";
        }

        Constructor<?>[] cs = clazz.getDeclaredConstructors();//
        sb.append("------ Constructor ------> ").append("\n");
        for (Constructor<?> c : cs) {
            sb.append(c.toString()).append("\n");
        }

        sb.append("------ Field ------>").append("\n");
        Field[] fs = clazz.getDeclaredFields();

        for (Field f : fs) {
            sb.append(f.toString()).append("\n");
        }
        sb.append("------ Method ------>").append("\n");
        Method[] ms = clazz.getDeclaredMethods();
        for (Method m : ms) {
            sb.append(m.toString()).append("\n");
        }
        return sb.toString();
    }
}

結(jié)果

  • static內(nèi)部類的默認(rèn)構(gòu)造函數(shù)： private com.example.administrator.mydemo.utils.Outer$StaticInner()

  • 非static內(nèi)部類的默認(rèn)構(gòu)造函數(shù)： private com.example.administrator.mydemo.utils.Outer$Inner(com.example.administrator.mydemo.utils.Outer),多了一個(gè)參數(shù)com.example.administrator.mydemo.utils.Outer,也就是說非static內(nèi)部類保持了外部類的引用。

  • 從屬性，我們也會(huì)發(fā)現(xiàn)多了一個(gè)final屬性final com.example.administrator.mydemo.utils.Outer com.example.administrator.mydemo.utils.Outer$Inner.this$0，這正是用于存儲(chǔ)外部類的屬性值。

工具類

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * 反射工具類，提供一些Java基本的反射功能
 */
public class ReflectUtils {
    public static final Class<?>[] EMPTY_PARAM_TYPES = new Class<?>[0];
    public static final Object[] EMPTY_PARAMS = new Object[0];

    /* ************************************************** 字段相關(guān)的方法 ******************************************************* */

    /**
     * 從指定的類中獲取指定的字段
     *
     * @param sourceClass         指定的類
     * @param fieldName           要獲取的字段的名字
     * @param isFindDeclaredField 是否查找Declared字段
     * @param isUpwardFind        是否向上去其父類中尋找
     * @return
     */
    public static Field getField(Class<?> sourceClass, String fieldName, boolean isFindDeclaredField, boolean isUpwardFind) {
        Field field = null;
        try {
            field = isFindDeclaredField ? sourceClass.getDeclaredField(fieldName) : sourceClass.getField(fieldName);
        } catch (NoSuchFieldException e1) {
            if (isUpwardFind) {
                Class<?> classs = sourceClass.getSuperclass();
                while (field == null && classs != null) {
                    try {
                        field = isFindDeclaredField ? classs.getDeclaredField(fieldName) : classs.getField(fieldName);
                    } catch (NoSuchFieldException e11) {
                        classs = classs.getSuperclass();
                    }
                }
            }
        }
        return field;
    }

    /**
     * 從指定的類中獲取指定的字段，默認(rèn)獲取Declared類型的字段、向上查找
     *
     * @param sourceClass 指定的類
     * @param fieldName   要獲取的字段的名字
     * @return
     */
    public static Field getField(Class<?> sourceClass, String fieldName) {
        return getField(sourceClass, fieldName, true, true);
    }

    /**
     * 獲取給定類的所有字段
     *
     * @param sourceClass         給定的類
     * @param isGetDeclaredField  是否需要獲取Declared字段
     * @param isGetParentField    是否需要把其父類中的字段也取出
     * @param isGetAllParentField 是否需要把所有父類中的字段全取出
     * @param isDESCGet           在最終獲取的列表里，父類的字段是否需要排在子類的前面。只有需要把其父類中的字段也取出時(shí)此參數(shù)才有效
     * @return 給定類的所有字段
     */
    public static List<Field> getFields(Class<?> sourceClass, boolean isGetDeclaredField, boolean isGetParentField, boolean isGetAllParentField, boolean isDESCGet) {
        List<Field> fieldList = new ArrayList<Field>();
        //如果需要從父類中獲取
        if (isGetParentField) {
            //獲取當(dāng)前類的所有父類
            List<Class<?>> classList = null;
            if (isGetAllParentField) {
                classList = getSuperClasss(sourceClass, true);
            } else {
                classList = new ArrayList<Class<?>>(2);
                classList.add(sourceClass);
                Class<?> superClass = sourceClass.getSuperclass();
                if (superClass != null) {
                    classList.add(superClass);
                }
            }

            //如果是降序獲取
            if (isDESCGet) {
                for (int w = classList.size() - 1; w > -1; w--) {
                    for (Field field : isGetDeclaredField ? classList.get(w).getDeclaredFields() : classList.get(w).getFields()) {
                        fieldList.add(field);
                    }
                }
            } else {
                for (int w = 0; w < classList.size(); w++) {
                    for (Field field : isGetDeclaredField ? classList.get(w).getDeclaredFields() : classList.get(w).getFields()) {
                        fieldList.add(field);
                    }
                }
            }
        } else {
            for (Field field : isGetDeclaredField ? sourceClass.getDeclaredFields() : sourceClass.getFields()) {
                fieldList.add(field);
            }
        }
        return fieldList;
    }

    /**
     * 獲取給定類的所有字段
     *
     * @param sourceClass 給定的類
     * @return 給定類的所有字段
     */
    public static List<Field> getFields(Class<?> sourceClass) {
        return getFields(sourceClass, true, true, true, true);
    }

    /**
     * 設(shè)置給定的對(duì)象中給定名稱的字段的值
     *
     * @param object              給定的對(duì)象
     * @param fieldName           要設(shè)置的字段的名稱
     * @param newValue            要設(shè)置的字段的值
     * @param isFindDeclaredField 是否查找Declared字段
     * @param isUpwardFind        如果在當(dāng)前類中找不到的話，是否取其父類中查找
     * @return 設(shè)置是否成功。false：字段不存在或新的值與字段的類型不一樣，導(dǎo)致轉(zhuǎn)型失敗
     */
    public static boolean setField(Object object, String fieldName, Object newValue, boolean isFindDeclaredField, boolean isUpwardFind) {
        boolean result = false;
        Field field = getField(object.getClass(), fieldName, isFindDeclaredField, isUpwardFind);
        if (field != null) {
            try {
                field.setAccessible(true);
                field.set(object, newValue);
                result = true;
            } catch (IllegalAccessException e) {
                e.printStackTrace();
                result = false;
            }
        }
        return result;
    }


    /* ************************************************** 方法相關(guān)的方法 ******************************************************* */

    /**
     * 從指定的類中獲取指定的方法
     *
     * @param sourceClass          給定的類
     * @param isFindDeclaredMethod 是否查找Declared字段
     * @param isUpwardFind         是否向上去其父類中尋找
     * @param methodName           要獲取的方法的名字
     * @param methodParameterTypes 方法參數(shù)類型
     * @return 給定的類中給定名稱以及給定參數(shù)類型的方法
     */
    public static Method getMethod(Class<?> sourceClass, boolean isFindDeclaredMethod, boolean isUpwardFind, String methodName, Class<?>... methodParameterTypes) {
        Method method = null;
        try {
            method = isFindDeclaredMethod ? sourceClass.getDeclaredMethod(methodName, methodParameterTypes) : sourceClass.getMethod(methodName, methodParameterTypes);
        } catch (NoSuchMethodException e1) {
            if (isUpwardFind) {
                Class<?> classs = sourceClass.getSuperclass();
                while (method == null && classs != null) {
                    try {
                        method = isFindDeclaredMethod ? classs.getDeclaredMethod(methodName, methodParameterTypes) : classs.getMethod(methodName, methodParameterTypes);
                    } catch (NoSuchMethodException e11) {
                        classs = classs.getSuperclass();
                    }
                }
            }
        }
        return method;
    }

    /**
     * 從指定的類中獲取指定的方法，默認(rèn)獲取Declared類型的方法、向上查找
     *
     * @param sourceClass          指定的類
     * @param methodName           方法名
     * @param methodParameterTypes 方法參數(shù)類型
     * @return
     */
    public static Method getMethod(Class<?> sourceClass, String methodName, Class<?>... methodParameterTypes) {
        return getMethod(sourceClass, true, true, methodName, methodParameterTypes);
    }

    /**
     * 從指定的類中獲取指定名稱的不帶任何參數(shù)的方法，默認(rèn)獲取Declared類型的方法并且向上查找
     *
     * @param sourceClass 指定的類
     * @param methodName  方法名
     * @return
     */
    public static Method getMethod(Class<?> sourceClass, String methodName) {
        return getMethod(sourceClass, methodName, EMPTY_PARAM_TYPES);
    }

    /**
     * 獲取給定類的所有方法
     *
     * @param clas                給定的類
     * @param isGetDeclaredMethod 是否需要獲取Declared方法
     * @param isFromSuperClassGet 是否需要把其父類中的方法也取出
     * @param isDESCGet           在最終獲取的列表里，父類的方法是否需要排在子類的前面。只有需要把其父類中的方法也取出時(shí)此參數(shù)才有效
     * @return 給定類的所有方法
     */
    public static List<Method> getMethods(Class<?> clas, boolean isGetDeclaredMethod, boolean isFromSuperClassGet, boolean isDESCGet) {
        List<Method> methodList = new ArrayList<Method>();
        //如果需要從父類中獲取
        if (isFromSuperClassGet) {
            //獲取當(dāng)前類的所有父類
            List<Class<?>> classList = getSuperClasss(clas, true);

            //如果是降序獲取
            if (isDESCGet) {
                for (int w = classList.size() - 1; w > -1; w--) {
                    for (Method method : isGetDeclaredMethod ? classList.get(w).getDeclaredMethods() : classList.get(w).getMethods()) {
                        methodList.add(method);
                    }
                }
            } else {
                for (int w = 0; w < classList.size(); w++) {
                    for (Method method : isGetDeclaredMethod ? classList.get(w).getDeclaredMethods() : classList.get(w).getMethods()) {
                        methodList.add(method);
                    }
                }
            }
        } else {
            for (Method method : isGetDeclaredMethod ? clas.getDeclaredMethods() : clas.getMethods()) {
                methodList.add(method);
            }
        }
        return methodList;
    }

    /**
     * 獲取給定類的所有方法
     *
     * @param sourceClass 給定的類
     * @return 給定類的所有方法
     */
    public static List<Method> getMethods(Class<?> sourceClass) {
        return getMethods(sourceClass, true, true, true);
    }

    /**
     * 獲取給定的類中指定參數(shù)類型的ValuOf方法
     *
     * @param sourceClass          給定的類
     * @param methodParameterTypes 方法參數(shù)類型
     * @return 給定的類中給定名稱的字段的GET方法
     */
    public static Method getValueOfMethod(Class<?> sourceClass, Class<?>... methodParameterTypes) {
        return getMethod(sourceClass, true, true, "valueOf", methodParameterTypes);
    }

    /**
     * 調(diào)用不帶參數(shù)的方法
     *
     * @param method
     * @param object
     * @return
     * @throws Exception
     */
    public static Object invokeMethod(Method method, Object object) throws
            Exception {
        return method.invoke(object, EMPTY_PARAMS);
    }

    /* ************************************************** 構(gòu)造函數(shù)相關(guān)的方法 ******************************************************* */

    /**
     * 獲取給定的類中給定參數(shù)類型的構(gòu)造函數(shù)
     *
     * @param sourceClass               給定的類
     * @param isFindDeclaredConstructor 是否查找Declared構(gòu)造函數(shù)
     * @param isUpwardFind              是否向上去其父類中尋找
     * @param constructorParameterTypes 構(gòu)造函數(shù)的參數(shù)類型
     * @return 給定的類中給定參數(shù)類型的構(gòu)造函數(shù)
     */
    public static Constructor<?> getConstructor(Class<?> sourceClass, boolean isFindDeclaredConstructor, boolean isUpwardFind, Class<?>... constructorParameterTypes) {
        Constructor<?> method = null;
        try {
            method = isFindDeclaredConstructor ? sourceClass.getDeclaredConstructor(constructorParameterTypes) : sourceClass.getConstructor(constructorParameterTypes);
        } catch (NoSuchMethodException e1) {
            if (isUpwardFind) {
                Class<?> classs = sourceClass.getSuperclass();
                while (method == null && classs != null) {
                    try {
                        method = isFindDeclaredConstructor ? sourceClass.getDeclaredConstructor(constructorParameterTypes) : sourceClass.getConstructor(constructorParameterTypes);
                    } catch (NoSuchMethodException e11) {
                        classs = classs.getSuperclass();
                    }
                }
            }
        }
        return method;
    }

    /**
     * 獲取給定的類中所有的構(gòu)造函數(shù)
     *
     * @param sourceClass               給定的類
     * @param isFindDeclaredConstructor 是否需要獲取Declared構(gòu)造函數(shù)
     * @param isFromSuperClassGet       是否需要把其父類中的構(gòu)造函數(shù)也取出
     * @param isDESCGet                 在最終獲取的列表里，父類的構(gòu)造函數(shù)是否需要排在子類的前面。只有需要把其父類中的構(gòu)造函數(shù)也取出時(shí)此參數(shù)才有效
     * @return 給定的類中所有的構(gòu)造函數(shù)
     */
    public static List<Constructor<?>> getConstructors(Class<?> sourceClass, boolean isFindDeclaredConstructor, boolean isFromSuperClassGet, boolean isDESCGet) {
        List<Constructor<?>> constructorList = new ArrayList<Constructor<?>>();
        //如果需要從父類中獲取
        if (isFromSuperClassGet) {
            //獲取當(dāng)前類的所有父類
            List<Class<?>> classList = getSuperClasss(sourceClass, true);

            //如果是降序獲取
            if (isDESCGet) {
                for (int w = classList.size() - 1; w > -1; w--) {
                    for (Constructor<?> constructor : isFindDeclaredConstructor ? classList.get(w).getDeclaredConstructors() : classList.get(w).getConstructors()) {
                        constructorList.add(constructor);
                    }
                }
            } else {
                for (int w = 0; w < classList.size(); w++) {
                    for (Constructor<?> constructor : isFindDeclaredConstructor ? classList.get(w).getDeclaredConstructors() : classList.get(w).getConstructors()) {
                        constructorList.add(constructor);
                    }
                }
            }
        } else {
            for (Constructor<?> constructor : isFindDeclaredConstructor ? sourceClass.getDeclaredConstructors() : sourceClass.getConstructors()) {
                constructorList.add(constructor);
            }
        }
        return constructorList;
    }


    /* ************************************************** 父類相關(guān)的方法 ******************************************************* */

    /**
     * 獲取給定的類所有的父類
     *
     * @param sourceClass       給定的類
     * @param isAddCurrentClass 是否將當(dāng)年類放在最終返回的父類列表的首位
     * @return 給定的類所有的父類
     */
    public static List<Class<?>> getSuperClasss(Class<?> sourceClass, boolean isAddCurrentClass) {
        List<Class<?>> classList = new ArrayList<Class<?>>();
        Class<?> classs;
        if (isAddCurrentClass) {
            classs = sourceClass;
        } else {
            classs = sourceClass.getSuperclass();
        }
        while (classs != null) {
            classList.add(classs);
            classs = classs.getSuperclass();
        }
        return classList;
    }


    /* ************************************************** 其它的輔助方法 ******************************************************* */

    /**
     * 獲取給定的類的名字
     *
     * @param sourceClass 給定的類
     * @return 給定的類的名字
     */
    public static String getClassName(Class<?> sourceClass) {
        String classPath = sourceClass.getName();
        return classPath.substring(classPath.lastIndexOf('.') + 1);
    }

    @SuppressWarnings("unchecked")
    public static <T> T getObjectByFieldName(Object object, String fieldName, Class<T> clas) {
        if (object != null && !TextUtils.isEmpty(fieldName) && clas != null) {
            try {
                Field field = ReflectUtils.getField(object.getClass(), fieldName, true, true);
                if (field != null) {
                    field.setAccessible(true);
                    return (T) field.get(object);
                } else {
                    return null;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        } else {
            return null;
        }
    }

    /**
     * 判斷給定字段是否是type類型的數(shù)組
     *
     * @param field
     * @param type
     * @return
     */
    public static final boolean isArrayByType(Field field, Class<?> type) {
        Class<?> fieldType = field.getType();
        return fieldType.isArray() && type.isAssignableFrom(fieldType.getComponentType());
    }

    /**
     * 判斷給定字段是否是type類型的collectionType集合，例如collectionType=List.class，type=Date.class就是要判斷給定字段是否是Date類型的List
     *
     * @param field
     * @param collectionType
     * @param type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static final boolean isCollectionByType(Field field, Class<? extends Collection> collectionType, Class<?> type) {
        Class<?> fieldType = field.getType();
        if (collectionType.isAssignableFrom(fieldType)) {
            Class<?>
                    first = (Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
            return type.isAssignableFrom(first);
        } else {
            return false;
        }
    }
}
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • /Library/Java/JavaVirtualMachines/jdk-9.jdk/Contents/Home...
    光劍書架上的書閱讀 4,196評(píng)論 2贊 8
  • Java反射總結(jié) 概述 通常在Java代碼中使用一個(gè)類，需要在編譯時(shí)知道類的位置。但是在某些時(shí)候，需要使用的類在編...
    ObadiObada閱讀 434評(píng)論 0贊 0
  • 概念介紹 Java反射機(jī)制JAVA反射機(jī)制是在運(yùn)行狀態(tài)中，對(duì)于任意一個(gè)類，都能夠知道這個(gè)類的所有屬性和方法；對(duì)于任...
    niaoge2016閱讀 574評(píng)論 0贊 2
  • 1. 右鍵單擊 Weka Application 2. 選擇“Show Package Contents" 3. ...
    海岸taurus閱讀 2,142評(píng)論 0贊 1
  • 隨著時(shí)間的推移，回想起很多往事，很多后悔，錯(cuò)過了很多，錯(cuò)過了陪孩子的時(shí)間，錯(cuò)過了陪父母的時(shí)間，2018，會(huì)多陪陪家人。
    茗楊天下閱讀 186評(píng)論 1贊 0

友情鏈接更多精彩內(nèi)容