[移动开发]Java 反射

一、根据一个字符串得到一个类

1、getClass

  String a = "22222";
  Class aClass = a.getClass();  //输出aClass:class java.lang.String

2、Class. forName()

 try {
       Class c1 = Class.forName("java.lang.String"); //class java.lang.String
       Class c2 = Class.forName("android.webkit.WebView");//class android.webkit.WebView
       Class c3 = c2.getSuperclass();// class android.widget.AbsoluteLayout

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

3、class属性

 //每一个类都有class属性，可以得到这个类的类型
        Class c4 = String.class; // class java.lang.String
        Class c5 = int.class; // int
        Class c6 = android.app.Activity.class; //class android.app.Activity

4、TYPE属性

 // 基本数据类型都有TYPE属性
 //基本数据类型 Boolean、String、Char、Byte、Integer、Float、Double、Short
        Class c7 = Boolean.TYPE;//boolean
        Class c8 = Void.TYPE;//void

二、获取类成员

测试类TestClassCtor：

/**
 *  用于测试的测试类
 */
public class TestClassCtor {
    public static final String TAG = TestClassCtor.class.getSimpleName();

    /**
     * 测试无参的构造方法
     */
    public TestClassCtor() {
    }

    /**
     * 测试带参数的公有构造方法
     * @param a
     */
    public TestClassCtor(int a){

    }

    /**
     * 测试带参数的私有构造方法
     * @param a
     * @param b
     */
     private TestClassCtor(int a,String b){
         Log.e(TAG," b->"+ b);

     }

    /**
     * 测试私有方法
     * @param d
     * @return
     */
     private String doSomething(String d){
        return "123"+d;
     }
}

1、获取类的构造函数

//1、获取所有构造函数
        TestClassCtor testClassCtor = new TestClassCtor();
        Class testClassCtorClass = testClassCtor.getClass();
        String name = testClassCtorClass.getName();

        //获取所有的构造函数
        Constructor[] declaredConstructors = testClassCtorClass.getDeclaredConstructors();
        for (int i = 0; i < declaredConstructors.length; i++) {
            int modifiers = declaredConstructors[i].getModifiers();
            Log.e(TAG,"构造函数名称:"+ name + "构造函数作用域："+ Modifier.toString(modifiers));

            //获取每个构造函数的参数
            Class[] parameterTypes = declaredConstructors[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                String paraName = parameterTypes[j].getName();
                Log.e(TAG,"参数名称："+ paraName);
            }
        }

输出结果：

分别打印了无参的公有构造函数，有一个int类型参数的公有构造函数，有一个int类型，一个String类型的私有构造函数。

2、获取类的某一个构造函数

 try {
            //  获取有一个参数的构造方法 ，类型为int
            Class[] c1 = {int.class};
            Constructor declaredConstructor = testClassCtorClass.getDeclaredConstructor(c1);
            Log.e(TAG,"获取到的构造方法名称："+declaredConstructor.getName());
            Log.e(TAG,"获取到的构造方法作用域："+Modifier.toString(declaredConstructor.getModifiers()));

            //获取有两个参数的构造方法
            Class[]  c2 = {int.class,String.class};
            Constructor declaredConstructor1 = testClassCtorClass.getDeclaredConstructor(c2);
            Log.e(TAG,"获取到的构造方法名称："+declaredConstructor1.getName());
            Log.e(TAG,"获取到的构造方法作用域："+Modifier.toString(declaredConstructor1.getModifiers()));

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

3、调用构造函数

  try {
            Class  getTestClass = Class.forName("com.cdv.reflectdemo.TestClassCtor");
            //含有参数
            Class[] c2 = {int.class,String.class};
            Constructor declaredConstructor = getTestClass.getDeclaredConstructor(c2);
            Object newInstance = declaredConstructor.newInstance(1, "3");

            //无参
            Constructor declaredConstructor1 = getTestClass.getDeclaredConstructor();
            Object newInstance1 = declaredConstructor.newInstance();
            
            //如果构造函数是无参的
            Object newInstance2 = getTestClass.newInstance();
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

4、获取类的私有方法并调用它

try {
            // 调用一个私有方法
            TestClassCtor getTestClass = new TestClassCtor();
            Method doSomething = getTestClass.getClass().getDeclaredMethod("doSomething", String.class);
            doSomething.setAccessible(true);
            doSomething.invoke(getTestClass,"hello");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

5、获取类的静态私有方法并调用

try {
            Class getTestClass = Class.forName("com.cdv.reflectdemo.TestClassCtor");
            Method testStaticMethod = getTestClass.getDeclaredMethod("testStaticMethod");
            testStaticMethod.setAccessible(true);
            testStaticMethod.invoke(null);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

6、获取类的私有字段并修改

try {
            TestClassCtor getTestClass = new TestClassCtor();
            Field testPrivateField = getTestClass.getClass().getDeclaredField("testPrivateField");
            testPrivateField.setAccessible(true);
            testPrivateField.set(getTestClass,"ceshishuju");

            Log.e(TAG,"获取到的testPrivateField："+ getTestClass.getTestPrivateField());
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }

7、获取类的静态私有字段并修改

try {
//获取到静态私有属性
            TestClassCtor getTestClass = new TestClassCtor();
            Field testStaticPrivateFiled = getTestClass.getClass().getDeclaredField("testStaticPrivateFiled");
            testStaticPrivateFiled.setAccessible(true);
            testStaticPrivateFiled.set(getTestClass,"hahahah");
//调用静态私有属性的Get方法
            Method getTestStaticPrivateFiled = getTestClass.getClass().getDeclaredMethod("getTestStaticPrivateFiled");
            getTestStaticPrivateFiled.setAccessible(true);
            Object invoke = getTestStaticPrivateFiled.invoke(null);
            Log.e(TAG,"获取到的testStaticPrivateFiled："+ invoke.toString());
        } catch (NoSuchFieldException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }

三、对泛型反射

Singleton类

/**
 *  对泛型进行反射
 * @param <T>
 */
public abstract class Singleton<T> {

    private T mInstance;

    protected abstract T mInstance();

    public  final T getmInstance(){
       synchronized (this){
           if(mInstance == null){
               mInstance = mInstance();
           }
           return mInstance;
       }
    }

}

try {
            Class aClass = Class.forName("com.cdv.reflectdemo.Singleton");
            Method mInstance = aClass.getDeclaredMethod("mInstance");
            mInstance.setAccessible(true);
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            e.printStackTrace();
        }

四、封装工具类

4.1、工具类的封装

public class RefInvoke {

    /**
     * 无参
     *
     * @param className 类的名称
     * @return 类的实例
     */
    public static Object createObject(String className) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};

        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 无参
     *
     * @param clazz 类的实例
     * @return 类的实例
     */
    public static Object createObject(Class clazz) {
        Class[] pareTyple = new Class[]{};
        Object[] pareVaules = new Object[]{};

        return createObject(clazz, pareTyple, pareVaules);
    }

    /**
     * 一个参数
     *
     * @param className 类的名称
     * @param pareTyple 参数类型
     * @param pareVaule 参数值
     * @return 类的实例
     */
    public static Object createObject(String className, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};

        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 一个参数
     *
     * @param clazz     类的实例
     * @param pareTyple 参数类型
     * @param pareVaule 参数值
     * @return 类的实例
     */
    public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};

        return createObject(clazz, pareTyples, pareVaules);
    }

    /**
     * 多个参数
     *
     * @param className  类的名称
     * @param pareTyples 参数类型
     * @param pareVaules 参数值
     * @return 类的实例
     */
    public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 多个参数
     *
     * @param clazz      类的实例
     * @param pareTyples 参数类型
     * @param pareVaules 参数值
     * @return 类的实例
     */
    public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
        try {
            Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
            ctor.setAccessible(true);
            return ctor.newInstance(pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }


    /**
     * 调用实例方法
     *
     * @param obj        类的实例
     * @param methodName 方法名称
     * @param pareTyples 参数类型
     * @param pareVaules 参数值
     * @return 如果方法有返回值, 返回反射调用后的返回值，如果是void 返回 null
     */
    public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
        if (obj == null) {
            return null;
        }
        try {
            //调用一个private方法
            Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples); //在指定类中获取指定的方法
            method.setAccessible(true);
            return method.invoke(obj, pareVaules);

        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 调用实例一个参数的方法
     *
     * @param obj        类的实例
     * @param methodName 方法名称
     * @param pareTyple  方法类型
     * @param pareVaule  方法值
     * @return 如果方法有返回值, 返回反射调用后的返回值，如果是void 返回 null
     */
    public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = {pareTyple};
        Object[] pareVaules = {pareVaule};

        return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
    }

    /**
     * 调用无参的方法
     *
     * @param obj        类的实例
     * @param methodName 方法名称
     * @return 如果方法有返回值, 返回反射调用后的返回值，如果是void 返回 null
     */
    public static Object invokeInstanceMethod(Object obj, String methodName) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};

        return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
    }


    /**
     * 调用无参数的静态方法
     *
     * @param className   类的名称
     * @param method_name 方法名称
     * @return 方法返回值  如果是void  返回null
     */
    public static Object invokeStaticMethod(String className, String method_name) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};

        return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
    }

    /**
     * 有一个参数的静态方法
     *
     * @param className  类的名称
     * @param method_name  方法名称
     * @param pareTyple  参数类型
     * @param pareVaule  参数值
     * @return 方法返回值  如果是void  返回null
     */
    public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};

        return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
    }

    /**
     * 多个参数的静态方法
     *
     * @param className  类的名称
     * @param method_name  方法名称
     * @param pareTyples  参数类型
     * @param pareVaules  参数值
     * @return 方法返回值  如果是void  返回null
     */
    public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
        try {
            Class obj_class = Class.forName(className);
            return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 无参静态方法
     * @param clazz  类的实例
     * @param method_name  方法名称
     * @return 方法返回值  如果是void  返回null
     */
    public static Object invokeStaticMethod(Class clazz, String method_name) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};

        return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
    }

    /**
     * 一个参数
     * @param clazz  类的实例
     * @param method_name  方法名称
     * @param classType  参数类型
     * @param pareVaule  参数值
     * @return 方法返回值  如果是void  返回null
     */
    public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
        Class[] classTypes = new Class[]{classType};
        Object[] pareVaules = new Object[]{pareVaule};

        return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
    }

    /**
     * 多个参数
     * @param clazz  类的实例
     * @param method_name  方法名称
     * @param pareTyples 参数类型
     * @param pareVaules  参数值
     * @return 方法返回值  如果是void  返回null
     */
    public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
        try {
            Method method = clazz.getDeclaredMethod(method_name, pareTyples);
            method.setAccessible(true);
            return method.invoke(null, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 获取属性的值
     * @param obj  类的实例
     * @param filedName  属性名称
     * @return 属性的值
     */
    public static Object getFieldObject(Object obj, String filedName) {
        return getFieldObject(obj.getClass(), obj, filedName);
    }

    /**
     * 获取属性的值
     * @param className  类的名称
     * @param obj 反射类的对象
     * @param filedName 属性名称
     * @return 属性的值
     */
    public static Object getFieldObject(String className, Object obj, String filedName) {
        try {
            Class obj_class = Class.forName(className);
            return getFieldObject(obj_class, obj, filedName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取字段属性值
     * @param clazz  类的实例
     * @param obj  反射类的对象
     * @param filedName   字段名称
     * @return
     */
    public static Object getFieldObject(Class clazz, Object obj, String filedName) {
        try {
            Field field = clazz.getDeclaredField(filedName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     *
     * @param obj
     * @param filedName
     * @param filedVaule
     */
    public static void setFieldObject(Object obj, String filedName, Object filedVaule) {
        setFieldObject(obj.getClass(), obj, filedName, filedVaule);
    }

    /**
     *
     * @param clazz
     * @param obj
     * @param filedName
     * @param filedVaule
     */
    public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
        try {
            Field field = clazz.getDeclaredField(filedName);
            field.setAccessible(true);
            field.set(obj, filedVaule);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @param className
     * @param obj
     * @param filedName
     * @param filedVaule
     */
    public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
        try {
            Class obj_class = Class.forName(className);
            setFieldObject(obj_class, obj, filedName, filedVaule);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }


    public static Object getStaticFieldObject(String className, String filedName) {
        return getFieldObject(className, null, filedName);
    }

    public static Object getStaticFieldObject(Class clazz, String filedName) {
        return getFieldObject(clazz, null, filedName);
    }

    public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
        setFieldObject(classname, null, filedName, filedVaule);
    }

    public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
        setFieldObject(clazz, null, filedName, filedVaule);
    }
}

4.2、工具类的使用

 try {
            Class getTestClass = Class.forName("com.cdv.reflectdemo.TestClassCtor");
            TestClassCtor object = (TestClassCtor) RefInvoke.createObject(getTestClass);
            String s = object.toString();
            Log.e(TAG, "s-》" + s);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }


        //一个参数
        TestClassCtor getTestClass = new TestClassCtor();
        Class paraType1 = int.class;
        Object paraValue1 = 1;
        RefInvoke.createObject(getTestClass.getClass(), paraType1, paraValue1);

        //获取类的方法 并调用
        String methodName = "doSomething";
        Class[] paraType2 = {String.class};
        Object[] paraValue2 = {"test->invokeInstanceMethod"};
        String result = (String) RefInvoke.invokeInstanceMethod(getTestClass, methodName, paraType2, paraValue2);
        Log.e(TAG, "result->" + result);


        // 无参数 私有 静态方法
        String testClassName = "com.cdv.reflectdemo.TestClassCtor";
        String testMethodName = "testStaticMethod";
        String result2 = (String) RefInvoke.invokeStaticMethod(testClassName, testMethodName);
        Log.e(TAG, "result2->" + result2);

        // 有参数  公有  静态方法
        Class paraType = String.class;
        Object paraValue = "有参数  公有  静态方法";
        String result3 = (String) RefInvoke.invokeStaticMethod(testClassName, testMethodName, paraType, paraValue);
        Log.e(TAG, "result3->" + result3);


        //获取属性
        getTestClass.setTestPrivateField("hello");
        String filedName = "testPrivateField";
        String fieldObject = (String) RefInvoke.getFieldObject(getTestClass, filedName);
        Log.e(TAG,"fieldObject-->"+ fieldObject);

        String fieldName = (String)RefInvoke.getFieldObject(testClassName,getTestClass,filedName);
        Log.e(TAG,"fieldName-->"+ fieldName);

五、参考代码

https://github.com/muyexiaogui/DailyExercise/tree/master/reflectdemo