这篇文章主要介绍了Java如何通过反射获取私有构造、私有对象、私有字段、私有方法，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

 

Java反射获取私有构造、私有对象、私有字段、私有方法

1. 创建测试的私有对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * @author lirong
 * @desc 测试对象
 * @date 2019/06/20 20:07
 */
public class Person {
    private int age = 5;
    private String name;
    private Person(){}
    private String test(String name){
        System.out.println("name: "+name);
        return "test";
    }
}

2. 获取私有对象中的属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * @author lirong
 * @desc 反射获取私有属性和方法
 * @date 2019/06/20 20:10
 */
public class Test {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        // 1. 获取class对象
        Class clazz = Person.class;
        // 2. 获取私有无参构造
        Constructor c = clazz.getDeclaredConstructor();
        // 3. 设置访问为可见
        c.setAccessible(true);
        // 4. 通过构造器创建实例对象
        Person person = (Person) c.newInstance();
         
        // 根据字段名称获取class中的字段
        Field age = clazz.getDeclaredField("age");
        age.setAccessible(true);
        System.out.println(age.getName() + " = " + age.get(person));
        // 修改私有变量的默认值
        age.set(person, 18);
        System.out.println(age.getName() + " = " + age.get(person));
        // 5. 获取所有字段
        Field[] fields = clazz.getDeclaredFields();
        for (Field f : fields) {
            // 设置字段的可见性
            f.setAccessible(true);
            String name = f.getName();
            Object o = f.get(person);
            System.out.println(name + " - " + o);
        }
        // 6. 获取所有的方法
        Method[] methods = clazz.getDeclaredMethods();
        for (Method m : methods) {
            m.setAccessible(true);
            String name = m.getName();
            Object invoke = m.invoke(person, "张三");
            System.out.println(name + " = "+invoke);
        }
    }
}

通过反射获取私有内部类对象

首先是我们的目标对象：

 

1
2
3
4
5
6
7
class Out {
    //目标获取Inner对象
    private class Inner {
        //内部类的私有成员属性
        private String inner = "ccc";
    }
}

直接列出代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Main {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) throws Exception {
        //获取外部类
        Class clzz = Out.class;
        //获取外部类默认无参构造方法
        Constructor con = clzz.getDeclaredConstructor();
        //实例一个外部类对象
        Out outObj = (Out) con.newInstance();
        //获取外部类内的所有内部类
        Class innerClazz[] = clzz.getDeclaredClasses();
        //遍历
        for (Class c : innerClazz) {
            //获取修饰符的整数编码
            int mod = c.getModifiers();
            //返回整数编码对应的修饰符的字符串对象
            String modifier = Modifier.toString(mod);
            //找到被private修饰的内部类
            if (modifier.contains("private")) {
                //根据内部类的特性，需要由外部类来反射获取内部类的构造方法（这里获取的是内部类的默认构造方法）
                Constructor cc = c.getDeclaredConstructor(clzz);
                //由于内部类是私有的，需要强制获取构造方法的访问权限
                cc.setAccessible(true);
                //由外部类对象来反射获取内部类的对象
                Object obj=cc.newInstance(outObj);
                //获取内部类的私有成员属性inner
                Field f=c.getDeclaredField("inner");
                //获取访问权限
                f.setAccessible(true);
                //获取内部类对象obj中的私有成员属性inner的值
                System.out.println(f.get(obj));
            }
        }
    }
}

输出结果：

ccc

转自：https://www.jb51.net/article/231877.htm