android 反射的原理与使用

反射：在运行状态下，通过class文件对象(Class的对象)，去使用构造方法，成员变量，成员方法。

获取class文件对象：有三种方法如下：

//1）Object类的getClass()方法。
Class c = p.getClass();

//（2）数据类型的静态的class属性
Class c3 = Person.class;

//（3）通过Class类的静态方法forName(String className)
Class c4 = Class.forName("cn.itcast_01.Person");

反射获取构造函数并创建对象

//思路：反射获取构造器，首先要获取待创建对象的类的class文件，通过class文件获//取构造器，得到构造方法，通过构造方法创建对象。
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
 
        // 获取构造器对象，此处获取的为带两个参数的构造方法
        Constructor con = c.getConstructor(String.class, int.class); 
 
        // 创建对象，创建对象方法为 newInstance()
        Object obj = con.newInstance("岳飞", 39); 
        System.out.println(obj);

1、反射获取Field对象属性

//（1）获取所有公共成员变量
Field[] fields = c.getFields();
//2）获取所有成员变量
Field[] fields = c.getDeclaredFields();
//（3）获取指定成员变量
Field field = c.getField("age");


//1.获取指定成员变量并赋值：
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
        
        //获取构造器对象，创建person类对象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
 
        // 获取单个age成员变量
        Field field = c.getField("age");
        
        // 给obj对象的field字段赋值
        field.set(obj, 20);
                
        System.out.println(obj);



//2.获取私有变量并赋值（在这个例子中age是私有变量）：
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
 
        // 创建对象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
 
        // 获取年龄并赋值
        Field ageField = c.getField("age");
        ageField.set(obj, 26);
 
        // 获取姓名字段        
        Field nameField = c.getDeclaredField("name"); 
 
        //暴力访问
        nameField.setAccessible(true);//因为是私有字段，所以必须解除访问限制，这一点很重要
        nameField.set(obj, "岳飞"); //通field对象为字段赋值

反射获取Method对象方法

（1）获取所有公共方法，包括父类的方法

Method[] methods = c.getMethods();

　　（2）获取本类的所有方法

Method[] methods = c.getDeclaredMethods();

　　（3）获取指定的成员方法


        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
 
        // 创建对象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
        
        //第一种：无参数无返回值
        Method m1 = c.getMethod("show", null);  //show是方法名称，后边是方法参数，null表示无参方法
        m1.invoke(obj, null);
 
        //第二种：带string类型参数无返回值
        Method m2 = c.getMethod("function", String.class); 
        m2.invoke(obj, "岳飞"); //invoke表示对方法进行调用
 
        //第三种：带多个参数有返回值 
        Method m3 = c.getMethod("reutrnValue", String.class,int.class);
        Object ooo = m3.invoke(obj, "张飞",26);
        System.out.println(ooo);
 
        //第四种：私有方法的调用
        Method m4 = c.getDeclaredMethod("hello", null);
        m4.setAccessible(true); //设置访问权限，这一点很重要
        m4.invoke(obj, null);

反射的使用有
1.调用@hide的系统api方法
https://www.jianshu.com/p/b43b417f1513

2.参数动态封装，赋值

//使用反射添加网络请求传参
FormBody.Builder builder = new FormBody.Builder();
//      如果是BaseModel 基内就不用添加
        if (!model.getClass().getSimpleName().equals(BaseModel.class.getSimpleName())) {
            //通过反射来获取字段名
            Field[] list = model.getClass().getDeclaredFields();
            for (Field field : list) {
                try {
                    Object object = field.get(model);
                    if (object != null && object instanceof String) {//这里为空的字段不用传到服务器
//                        Log.i("tag","field.getName():"+field.getName() +";field.get(model):"+field.get(model));
                        builder.add(field.getName(), (String) field.get(model));
                    }
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

public class Utils {
    private static final String TAG = "Utils";

    public Object setObjectValue(Object object, String json) throws Exception {
        if (object == null)
            return null;
        Log.d(TAG, "setObjectValue");
        Class<?> clazz = object.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            Log.d(TAG, "field type:" + field.getName());// 打印字段的类型
            if (field.getGenericType().toString().equals("class java.lang.String")) {
                Method method = object.getClass().getMethod("set" + getMethodName(field.getName()), String.class);
                method.invoke(object, parseJson(json, field.getName()));

            }

            if (field.getGenericType().toString().equals("class java.lang.Integer"))//
            {
                Method method = object.getClass().getMethod("set" + getMethodName(field.getName()), Integer.class);
                method.invoke(object, parseJson(json, field.getName()));
            }
            
        }
        return object;
    }

    /**
     * 解析json
     * */
    private String parseJson(String json_string, String name) {
        String str = "no info";
        JSONObject json;
        try {
            json = new JSONObject(json_string);
            json = json.getJSONObject("studentinfo");
            str = json.getString(name);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 将属性名称的首字母变成大写
     * */
    public String getMethodName(String fieldName) {
        byte[] bytes = fieldName.getBytes();
        bytes[0] = (byte) (bytes[0] - 'a' + 'A');
        return new String(bytes);
    }

}

关于kotlin 版本的反射，跟Java区别不大
可以参考这个
https://www.jianshu.com/p/8f53f52e49b5