通过反射调用内部类的隐藏方法

可以通过反射来调用那些非公共访问权限的方法。对于final域实际上在修改时是安全的。运行时系统人在不招聘异常的情况下接受任何修改的尝试，但是实际上不会发生任何修改。在类中留下这种后门，也许可以使我们能够解决某一特定类型的问题。

/**
 * 通过反射来调用内部类的私有方法
 */
package typeinfo;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

interface A{
    void f();
}
class InnerA{
    private static class InnerB implements A{
        private int i=1;
        private final String s="I'm totally safe.";
        private void g() {
            System.out.println("private g() ");
        }
        @Override
        public void f() {
            System.out.println("public f()");
        }
        protected void h(){
            System.out.println("protected h()");
        }
        void v(){
            System.out.println("package v()");
        }
        public String toString(){
            return "i="+i+", s="+s;
        }
    }
    public static A makeA(){
        return new InnerB();
    }
}
/**
 * @author LYL
 *
 */
public class InnerImplemetation {
    /**
     * 通过反射来调用对象的某一方法
     * @param a
     * @param methodName
     * @throws Exception
     */
    public static void callHiddenMethod(Object a,String methodName) throws Exception{
        Method method=a.getClass().getDeclaredMethod(methodName);
        //设置为可访问
        method.setAccessible(true);
        method.invoke(a);
    }
    
    public static Field modifyPrivateField(Object a,String fieldName) throws Exception{
        Field field=a.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        return field;
    }
    public static void main(String args[]) throws Exception{
        A a=InnerA.makeA();
        //显示出typeinfo.InnerA$InnerB
        System.out.println(a.getClass());
        //
        a.f();
        //通过反射来调用对象的隐藏方法
        callHiddenMethod(a,"g");
        callHiddenMethod(a,"h");
        callHiddenMethod(a,"v");
        
        Field fieldI=modifyPrivateField(a,"i");
        fieldI.setInt(a,12);
        System.out.println("Private field I:"+fieldI.getInt(a));
        Field field=modifyPrivateField(a,"s");
        field.set(a, "new value");
        System.out.println("final s:"+field.get(a));
        //
        System.out.println(a);        
    }
}

输出：
class typeinfo.InnerA$InnerB
public f()
private g()
protected h()
package v()
Private field I:12
final s:new value
i=12, s=I'm totally safe.