Java 从该方法参数的属性获取方法返回类型

我有一个具有内部类属性的类C：

public class C{
   private Class<?> clazz;

   public void setClazz(Class<?> c){
      this.clazz = c;
   }

   public Class<?> getClazz(){
      return clazz;
   }
}

公共C类{
私人课堂；
公共空间分类（c类）{
this.clazz=c；
}
公共类getClazz（）{
回击声；
}
}

我想在另一个类中声明一个方法，因此它的返回类型是C.clazz的返回类型：

public class D{
    public <T> T getInstance(C c){
       //doesn't compile
       //some reflective code to set T to c.getClazz?
       return (c.getClazz.newInstance());
    }
}  

公共类D{
公共T getInstance（C）{
//不编译
//将T设置为c.getClazz的一些反射代码？
返回（c.getClazz.newInstance（））；
}
}  

因此，例如，getInstance（c），其中c将clazz设置为

Class

，将返回一个新的B实例。有没有方法通过反射来实现这一点？

您需要

getClazz（）

和转换为

T

：

public class D {
    public <T> T getInstance(C c) throws InstantiationException, IllegalAccessException {
        return (T)(c.getClazz().newInstance());
    }
}

公共类D{
public T getInstance（C）抛出实例化异常，IllegalAccessException{
return（T）（c.getClazz（）.newInstance（））；
}
}

公共C类{
私人课堂；
公共空间分类（c类）{
this.clazz=c；
}
公共类getClazz（）{
回击声；
}
}
D类公共服务{
公共T getInstance（C）{
//不编译
//将T设置为c.getClazz的一些反射代码？
返回c.getClazz（）.newInstance（）；
}
公共T getInstance2（C类C类）{
//不编译
//将T设置为c.getClazz的一些反射代码？
返回clazz.cast（c.getClazz（）.newInstance（））；
}
}

getInstance

需要一个带T参数的C，否则

getInstance2

需要一个类作为参数，并执行不安全的强制转换（您可以添加一个检查）。

类C{
私人期末班；
C级（课堂）{
this.clazz=clazz；
}
公共类getClazz（）{
回击声；
}
}
D类{
公共T getInstance（CT）抛出IllegalAccessException、InstanceionException{
返回t.getClazz（）.newInstance（）；
}
}
public static void main（）引发异常{
C=新的C（String.class）；
D=新的D（）；
字符串s=d.getInstance（c）；
System.out.println（“String=“+s”）；
}

这也是存储泛型类型信息的经典方法。但是我不明白你为什么想要

getInstace

方法在

D

中。我宁愿在

C

中使用静态方法

即使是带有

java.lang.reflect.array.newInstance（t.getClazz（），10）的数组，也可以采用类似的策略而不仅仅是
t.getClazz（）.newInstance（）

甚至还有其他方法可以捕获泛型类型信息。这适用于更复杂的内容。
注意：代码中缺少类D的结束括号。至于C类newInstance（）方法，它不能是静态的，因为类型将在C实例对象上确定。而且并非每个类型都有非参数构造函数，因此最好将其设置在类之外。
public class C<T> {
    private Class<T> clazz;

    public void setClazz(Class<T> c){
        this.clazz = c;
    }

    public Class<T> getClazz(){
        return clazz;
    }
}

public class D {
    public <T> T getInstance(C<T> c){
       //doesn't compile
       //some reflective code to set T to c.getClazz?
       return c.getClazz().newInstance();
    }
    public <T> T getInstance2(C c, Class<T> clazz){
       //doesn't compile
       //some reflective code to set T to c.getClazz?
       return clazz.cast(c.getClazz().newInstance());
    }
}

class C<T>{
    private final Class<T> clazz;

    C(Class<T> clazz) {
        this.clazz = clazz;
    }

    public Class<T> getClazz(){
        return clazz;
    }
}

class D{
    public <T> T getInstance(C<T> t) throws IllegalAccessException, InstantiationException {
        return t.getClazz().newInstance();
    }
}


public static void main() throws Exception {
    C<String> c = new C<>(String.class);
    D d = new D();
    String s = d.getInstance(c);
    System.out.println("String = " + s);
}