使用反射操作类的私有属性(Field)和私有方法(Method)

刚刚了解了反射,看到了使用反射操作类的私有属性,在操作私有变量时，需要使用Field类,我们来看一个例子:

   // field访问私有变量
    private void useFeildOfReflect() throws Exception {
    //获取类的class对象
        Class<?> cls = Class.forName("com.xiao.reflectclass.User");
        //获取User类的实例
        User user = (User) cls.newInstance();
//使用Field中的方法获取User的私有属性
        Field fieldName = cls.getDeclaredField("userName");//Field访问私有变量
        fieldName.setAccessible(true);//允许访问私有变量
        user.setUserName("yxs");//设置私有变量的值

        Field fieldAge = cls.getDeclaredField("age");//Feild访问私有变量
        fieldAge.setAccessible(true);
        user.setAge(25);

        Field fieldSex = cls.getDeclaredField("sex");//Field访问私有变量
        fieldSex.setAccessible(true);
        user.setSex("男");

        LogSystem.print(user.toString() + "\n私有属性操作");

    }
    User类如下:

    public class User implements Serializable{

    public User() {
        super();
    }

    public User(String userName, int age, String sex) {
        this.userName = userName;
        this.age = age;
        this.sex = sex;
    }

    private String userName;

    private int age;

    private String sex;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "年龄"+age+"\n"+"姓名"+userName+"\n"+"性别"+sex;
    }
}

下面说一下，使用反射调用类的私有方法(Method).
我们先来写一个类,类里面有两个公开方法和一个私有方法.

public class LogSystem {
    public static String Tag = "yxs";
    public static void print(String msg){
        Log.i(Tag,msg);
    }

    public void cal(int f,int s){
        print((f+s)+"结果");
    }

    private void cal(int f,int s,int t){
        print((f*s*t)+"私有结果");
    }
}

代码很简单,写好之后，我们开始使用反射:
第一步.我们获取类的class对象:

 Class<?> cls = Class.forName("com.xiao.reflectclass.LogSystem");

也可以这样获取:

 Class<?> cls = new LogSystem().getClass();

或者这样获取:

Class<?> cls3 =   LogSystem.class;

java提供了三种方法获取类的class对象,上面三种就是,我们通过类的class对象来操作程序.
获取到类的class对象之后，我们通过class对象来获取类的实例:

LogSystem ls = (LogSystem) cls.newInstance();//获得类的实例

我们需要明白在JAVA中任何class都要装载在虚拟机上才能运行，而forName就是装载类用的，这和new不一样，要分清楚哦。

A a = (A)Class.forName(“package.A”).newInstance();
和 
A a = new A;两行代码是等价的。

第三步，我们通过cls获取类的共有方法:

     //公有方法1
        Method method = cls.getMethod("print", String.class);
        method.invoke(ls, "hahahahah");

还记得第一步我们写的那个类吗?去看一下吧,我们获取到print方法,print方法有一个参数,这个参数是String类型的,getMethod方法，要求我们传入方法的名称(String类型)，和方法需要传入的参数的class对象,我们来看一下源码:

public Method getMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        return getMethod(name, parameterTypes, true);
    }

第二参数要我们传入参数，允许传入多个参数,但是他抛出了异常，因为我们可能是非法操作类的方法，然后，该方法调用另一个getMethod方法,返回匹配指定的方法对象：

private Method getMethod(String name, Class<?>[] parameterTypes, boolean recursivePublicMethods)
            throws NoSuchMethodException {
        if (name == null) {
            throw new NullPointerException("name == null");
        }
        if (parameterTypes == null) {
            parameterTypes = EmptyArray.CLASS;
        }
        for (Class<?> c : parameterTypes) {
            if (c == null) {
                throw new NoSuchMethodException("parameter type is null");
            }
        }
        Method result = recursivePublicMethods ? getPublicMethodRecursive(name, parameterTypes)
                                               : getDeclaredMethodInternal(name, parameterTypes);
        // Fail if we didn't find the method or it was expected to be public.
        if (result == null ||
            (recursivePublicMethods && !Modifier.isPublic(result.getAccessFlags()))) {
            throw new NoSuchMethodException(name + " " + Arrays.toString(parameterTypes));
        }
        return result;
    }

代码做了一些判断，包括方法名是否为空,参数是否为空,最后因该是判断此方法是私有还是公有方法,这里recursivePublicMethods 默认是为true的，也就是说，我们调用getMethod方法时，就已经确定了调用的是公有方法.
我们使用Method对象来接受返回的数据，因为最终返回的是method类型，也就是方法,然后调用invoke来执行方法，看一下源码中invoke方法的解释:

   /**
     * Invokes the underlying method represented by this {@code Method}
     * object, on the specified object with the specified parameters.
     * Individual parameters are automatically unwrapped to match
     * primitive formal parameters, and both primitive and reference
     * parameters are subject to method invocation conversions as
     * necessary.
     *
     * <p>If the underlying method is static, then the specified {@code obj}
     * argument is ignored. It may be null.
     *
     * <p>If the number of formal parameters required by the underlying method is
     * 0, the supplied {@code args} array may be of length 0 or null.
     *
     * <p>If the underlying method is an instance method, it is invoked
     * using dynamic method lookup as documented in The Java Language
     * Specification, Second Edition, section 15.12.4.4; in particular,
     * overriding based on the runtime type of the target object will occur.
     *
     * <p>If the underlying method is static, the class that declared
     * the method is initialized if it has not already been initialized.
     *
     * <p>If the method completes normally, the value it returns is
     * returned to the caller of invoke; if the value has a primitive
     * type, it is first appropriately wrapped in an object. However,
     * if the value has the type of an array of a primitive type, the
     * elements of the array are <i>not</i> wrapped in objects; in
     * other words, an array of primitive type is returned.  If the
     * underlying method return type is void, the invocation returns
     * null.
     *
     * @param receiver  the object the underlying method is invoked from
     * @param args the arguments used for the method call
     * @return the result of dispatching the method represented by
     * this object on {@code obj} with parameters
     * {@code args}
     *
     * @exception IllegalAccessException    if this {@code Method} object
     *              is enforcing Java language access control and the underlying
     *              method is inaccessible.
     * @exception IllegalArgumentException  if the method is an
     *              instance method and the specified object argument
     *              is not an instance of the class or interface
     *              declaring the underlying method (or of a subclass
     *              or implementor thereof); if the number of actual
     *              and formal parameters differ; if an unwrapping
     *              conversion for primitive arguments fails; or if,
     *              after possible unwrapping, a parameter value
     *              cannot be converted to the corresponding formal
     *              parameter type by a method invocation conversion.
     * @exception InvocationTargetException if the underlying method
     *              throws an exception.
     * @exception NullPointerException      if the specified object is null
     *              and the method is an instance method.
     * @exception ExceptionInInitializerError if the initialization
     * provoked by this method fails.
     */
    public native Object invoke(Object receiver, Object... args)
            throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;

我们把多余注释去掉，再看一下:

  /* @param receiver  the object the underlying method is invoked from
     * @param args the arguments used for the method call
     * @return the result of dispatching the method represented by
     * this object on {@code obj} with parameters
     */
      public native Object invoke(Object receiver, Object... args)
            throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;

*看看每个参数的意思:
第一个代表了(调用方法的对象),我认为谁的方法谁调用
第二个参数代表:需要的参数列表,逗号分隔.
所以我们再使用method调用类的方法时，需要传入类的实例和参数列表!*
公有方法说完了，说一下私有方法.
前面说到:在调用公共方法时:

  //公有方法1
        Method method = cls.getMethod("print", String.class);
        method.invoke(ls, "hahahahah");

使用类的class对象调用getMethod方法,这个方法默认是公共方法,但是访问私有方法时不是这样的，我们需要调用另一个方法:

  //执行私有方法
        method = cls.getDeclaredMethod("cal", int.class, int.class, int.class);
        method.setAccessible(true);
        method.invoke(ls, 2, 3, 4);

虽然方法名称不同，但是他们的代码中却调用了同一个方法,就是getMethod方法,千万不要误会，这个getMethod方法是一个重载方法。与我们直接调用的是同名不同参的方法.

//源码:
 public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        return getMethod(name, parameterTypes, false);
    }

在调用公有方法时,在上面getMethod方法的第三个参数，源码中默认填写了true，但是此时却是false，因为我们此时调用的是一个私有方法。
同时我们需要调用:

method.setAccessible(true);

来设置可访问性。我们来看一下此方法解释:

Set the accessible flag for this object to the indicated boolean value.  A value of true indicates that the reflected object should suppress Java language access checking when it is used.  A value of  false indicates that the reflected object should enforce Java language access checks.
将此对象的可访问标志设置为所指示的布尔值。true值表明反射的对象应当压制java语言访问检查时。false表示反映的对象应执行java语言访问检查。

如果我们设置true，表示我们访问私有方法时尽量不受到权限检查,如果设置为false，代表我们要接受java权限检查,所以我们填写true，不接受权限检查。
在调用getDeclaredMethod方法时，和调用getMethod方法一样，我们需要传入:方法名,每个参数对应的class对象。
最后执行invoke方法,传入类的实例,和真正的参数!

method.invoke(ls, 2, 3, 4);