是否可以使用 Java 反射从另一个类实例化私有内部类。例如，如果我使用此代码
public class Main {
public static void main(String[] args) {}
}
class OtherClass {
private class Test {}
}
是否可以从 main 类中的 main 方法实例化并获得对 Test 的访问权限。
问问题
48260 次
3 回答
42
是的，您可以使用 Java 反射实例化私有内部类。为此，您需要有一个外部类的实例并调用内部类构造函数，该构造函数将在其第一个参数中使用外部类实例。
class OuterClass {
private class InnerClass {
{
//this block is just to confirm that the inner object was created
//it will be added to every constructor of this class
System.out.println("inner object created");
}
}
}
当我们不知道私有内部类的名称并且我们假设它具有无参数构造函数时：
class Main {
//no comment version
public static Object giveMeInnerInstance() throws Exception{
OuterClass outerObject = new OuterClass();
Class<?> innerClass = OuterClass.class.getDeclaredClasses()[0];
Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
constructor.setAccessible(true);
return constructor.newInstance(outerObject);
}
//commented version
public static void main(String[] args) throws Exception {
//we need an outer class object to use the inner object constructor
//(the inner class object needs to know about its parent object)
OuterClass outerObject = new OuterClass();
//let's get the inner class
//(we know that the outer class has only one inner class, so we can use index 0)
Class<?> innerClass = OuterClass.class.getDeclaredClasses()[0];
//or if we know name of inner class we can use
//Class<?> innerClass = Class.forName("full.package.name.OuterClass$InnerClass")
//since constructor so we could use it to pass instance of outer class and change
//its accessibility. We can use this code to get default constructor of InnerClass
//since we know that this is the only constructor here
Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
//we could also use
//Constructor<?> constructor = innerClass.getDeclaredConstructor(OuterClass.class);
//the default constructor of the private class has same visibility that class has
//so it is also private, so to be able to use it we need to make it accessible
constructor.setAccessible(true);
//now we are ready to create inner class instance
Object innerObject = constructor.newInstance(outerObject);
}
}
现在，如果我们有类似的信息，我们可以使这段代码更清晰
- 内部类的名称，
- 构造函数参数
因此，我们可以通过名称获取选定的内部类，而不是检查内部类列表并选择第一个，使用
Class<?> inner = Class.forName("our.pack.age.OuterClass$InnerClass")
// ^^^^^^^^^^^
同样，我们可以通过调用来选择我们想要使用的构造函数，getDeclaredConstructor(outerType,rest,of,parameter,types)所以如果我们的内部类看起来像
class OuterClass {
private class InnerClass {
private int x;
public InnerClass(int x) {
this.x = x;
System.out.println("inner object created");
}
}
}
我们的代码可能是
class ReflectionDemo {
//no comment version
public static Object giveMeInnerInstance() throws Exception{
OuterClass outerObject = new OuterClass();
Class<?> innerClass = Class.forName("com.stackoverflow.q14112166.OuterClass$InnerClass");
Constructor<?> constructor = innerClass.getDeclaredConstructor(OuterClass.class, int.class);
constructor.setAccessible(true);
return constructor.newInstance(outerObject,42);
}
public static Object getFieldValue(Object obj, String fieldName) throws Exception{
Class<?> clazz = obj.getClass();
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
return field.get(obj);
}
//lets test our code
public static void main(String[] args) throws Exception {
Object innerClassObject = giveMeInnerInstance();
System.out.println(getFieldValue(innerClassObject, "x"));
}
}
输出：
inner object created
42
于 2013-01-01T16:51:21.717 回答
18
使用反射时，您会发现该内部类的构造函数将外部类的实例作为附加参数（始终是第一个参数）。
有关相关信息，请参阅这些问题：
例子：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class OuterClass {
private class InnerClass {
}
public OuterClass() {
super();
}
public static void main(String[] args) {
// instantiate outer class
OuterClass outer = new OuterClass();
// List all available constructors.
// We must use the method getDeclaredConstructors() instead
// of getConstructors() to get also private constructors.
for (Constructor<?> ctor : OuterClass.InnerClass.class
.getDeclaredConstructors()) {
System.out.println(ctor);
}
try {
// Try to get the constructor with the expected signature.
Constructor<InnerClass> ctor = OuterClass.InnerClass.class
.getDeclaredConstructor(OuterClass.class);
// This forces the security manager to allow a call
ctor.setAccessible(true);
// the call
try {
OuterClass.InnerClass inner = ctor.newInstance(outer);
System.out.println(inner);
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
于 2013-01-01T17:01:27.960 回答
1
您可以执行以下操作：
public static void main(String[] args) throws Exception {
// to get first class in OtherClass
Class<?> innerClass = OtherClass.class.getDeclaredClasses()[0];
// getDeclaredConstructors for private constructor
Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
// to enable accessing private constructor
constructor.setAccessible(true);
OtherClass outerObject = new OtherClass();
//// create instance of Test by reflection
Object o = constructor.newInstance(outerObject);
System.out.println(o);
}
于 2019-12-26T16:16:37.773 回答