Java 实例化内部类

我有一个实用方法，当从中删除不相关的逻辑时，简化方法如下所示：

public static <A extends Foo> List<A> getFooList(Class<A> clazz) {
   List<A> returnValue = new ArrayList<A>();
   for(int i=0; i < 5; i++) {
        A object = clazz.newInstance();
        returnValue.add(object);
   }

   return returnValue;
}

publicstaticlist-get傻瓜列表（类clazz）{
List returnValue=new ArrayList（）；
对于（int i=0；i<5；i++）{
对象=clazz.newInstance（）；
returnValue.add（对象）；
}
返回值；
}

问题是，如果

clazz

是一个内部类，例如

Foo.Bar.class

，那么

newInstance（）

方法将不起作用，即使

Bar

是公共的，因为它将抛出

java.lang.InstanceException

有没有一种方法可以动态实例化内部类？

如果它确实是一个内部类而不是嵌套（静态）类，那么就有一个隐式构造函数参数，它是对外部类实例的引用。在该阶段，您不能使用

Class.newInstance

——您必须获得适当的构造函数。下面是一个例子：

import java.lang.reflect.*;

class Test
{
    public static void main(String[] args) throws Exception
    {
        Class<Outer.Inner> clazz = Outer.Inner.class;

        Constructor<Outer.Inner> ctor = clazz.getConstructor(Outer.class);

        Outer outer = new Outer();
        Outer.Inner instance = ctor.newInstance(outer);
    }
}

class Outer
{
    class Inner
    {
        // getConstructor only returns a public constructor. If you need
        // non-public ones, use getDeclaredConstructors
        public Inner() {}
    }
}

import java.lang.reflect.*；
课堂测试
{
公共静态void main（字符串[]args）引发异常
{
clazz类=Outer.Inner.Class；
Constructor=clazz.getConstructor（Outer.class）；
外部=新的外部（）；
Outer.internal实例=ctor.newInstance（Outer）；
}
}
类外部
{
班级内部
{
//getConstructor只返回一个公共构造函数
//非公共的，使用getDeclaredConstructors
公共内部（）{}
}
}

仅当clazz表示抽象类或接口时，才会引发此异常。确实要传递一个表示具体类的类对象吗？

更一般的东西：

    public static <T> T createInstance(final Class<T> clazz) throws SecurityException, NoSuchMethodException,
            IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {

            T instanceToReturn = null;
            Class< ? > enclosingClass = clazz.getEnclosingClass();

            if (enclosingClass != null) {
                Object instanceOfEnclosingClass = createInstance(enclosingClass);

                Constructor<T> ctor = clazz.getConstructor(enclosingClass);

                if (ctor != null) {
                    instanceToReturn = ctor.newInstance(instanceOfEnclosingClass);
                }
            } else {
                instanceToReturn = clazz.newInstance();
            }

            return instanceToReturn;
     }

public static T createInstance（最终类clazz）抛出SecurityException、NoSuchMethodException、，
IllegalArgumentException、InstanceionException、IllegalAccessException、InvocationTargetException{
T instanceToReturn=null；
Class<？>enclosuringclass=clazz.getenclosuringclass（）；
if（封闭类！=null）{
对象InstanceOffnclosingClass=createInstance（封闭类）；
Constructor=clazz.getConstructor（封闭类）；
如果（ctor！=null）{
instanceToReturn=ctor.newInstance（InstanceOffnclosingClass）；
}
}否则{
instanceToReturn=clazz.newInstance（）；
}
返回瞬间返回；
}

在Jmockit 1.41中，使用以下命令：

ConstructorReflection.newInstance