Java 如何从具有泛型类型的变量中获取类

我有一个变量，比如

Function<T, String> myFn;

我们可以使用x.getClass（）获得Integer.class

编辑：我们是否可以在不使用反射的情况下执行此操作

编辑：更完整的示例

class MyFnClass<T> {
    Function<T, String> myFn;
    ...
    public Class<T> getTypeClass() {
       ???
    }
}

类MyFnClass{
功能性myFn；
...
公共类getTypeClass（）{
???
}
}

请注意，它不必使用myFn，但由于我们不能使用t.class或其他什么，我认为myFn是实现这一点的唯一方法。在这种情况下，不使用myFn的解决方案也是可以接受的。

我们可以从如下变量访问该类：
We can access the class from a variable like this:

    myLocalVar = myClass.getMyVarVal();

Please refer this case as below :

public class myClass<T> {

    protected Class<T> clazz;

    public myClass() {
        this.clazz = (Class<>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

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

public class Fetch extends myClass<C> {
   /* ... */
    public void fetchClassFromVariable() {
       //here we can call getClazz() to get the class from variable
    }
}

myLocalVar=myClass.getMyVarVal（）；
请参考以下案例：
公共类myClass{
保护类clazz；
公共myClass（）{
this.clazz=（Class）（（ParameterizedType）getClass（）.getGenericSuperclass（））.getActualTypeArguments（）[0]；
}
公共类getClazz（）{
回击声；
}
}
公共类获取扩展了myClass{
/* ... */
public void fetchClassFromVariable（）{
//在这里，我们可以调用getClazz（）从变量获取类
}
}

Java使用的意思是在编译时删除与泛型相关的类型信息

因此，在运行时无法从

函数

获取类型

T

在包含的代码段中，可以执行以下操作：

public abstract class AbstractFunction<T> 
{
  private Function<T, String> function;

  ...

  public Class<T> getInputType() throws ClassNotFoundException
  {
    return (Class<T>)Class.forName(((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName());
  }
}

public IntegerFunction extends AbstractFunction<Integer>
{
}

公共抽象类抽象函数
{
私人职能；
...
公共类getInputType（）引发ClassNotFoundException
{
返回（类）Class.forName（（（ParameterizedType）getClass（）.getGenericSuperclass（））.getActualTypeArguments（）[0].getTypeName（））；
}
}
公共整数函数扩展了抽象函数
{
}

虽然所有这些都非常棘手，但它不必要地复杂，可以简化为：

public abstract class AbstractFunction<T> 
{
  private Function<T, String> function;

  ...

  public abstract Class<T> getInputType();
}

public IntegerFunction extends AbstractFunction<Integer>
{
  @Override
  public Class<Integer> getInputType()
  {
    return Integer.class;
  }
}

公共抽象类抽象函数
{
私人职能；
...
公共抽象类getInputType（）；
}
公共整数函数扩展了抽象函数
{
@凌驾
公共类getInputType（）
{
返回Integer.class；
}
}

这仍然引入了一个毫无意义的类，可以进一步简化为：

public class MyFunction<T> 
{
  private Class<T> inputType;
  private Function<T, String> function;

  public MyFunction(Class<T> inputType, Function<T, String> function)
  {
    this.inputType = inputType;
    this.function = function;
  }

  public Class<T> getInputType()
  {
    return inputType;
  }
}

公共类MyFunction
{
私有类输入类型；
私人职能；
公共MyFunction（类输入类型、函数）
{
this.inputType=inputType；
这个函数=函数；
}
公共类getInputType（）
{
返回输入类型；
}
}

---

总而言之，需要知道泛型类型有点困难，可能表明您的设计中还有其他不太正确的地方。

此变量是泛型类型中的字段吗？泛型类型中的

函数

，与非泛型类型中的

函数

之间有很大区别。一个简短但完整的例子在这里会很有帮助。（您所要求的可能是可能的，但可能不是…）请注意，如果

x

的值为非空，则只能从

x.getClass（）

中获取

Integer.class

。@JonSkeet:我可以放心地假设实例变量为非空-null@user34812请检查我的解决方案，它应该help@VivekSingh：对不起，我应该提到解决方案不应该使用反射。现在编辑问题请详细说明你的答案。我不知道这些标识符代表什么。在这里发表评论之前，您需要先学习oops和java的基础知识。只有当您能够以某种方式获得类型为

t

的对象时，才有可能执行

thatObj.getClass（）

。尽管如此，它仍然可能是T的子类型或匿名类，除非

T

使用的类是final。（

Integer

为最终值。）最好将

T

声明为

T扩展了Number

或其他内容，至少要知道T的上限（类的范围）。

public abstract class AbstractFunction<T> 
{
  private Function<T, String> function;

  ...

  public abstract Class<T> getInputType();
}

public IntegerFunction extends AbstractFunction<Integer>
{
  @Override
  public Class<Integer> getInputType()
  {
    return Integer.class;
  }
}

public class MyFunction<T> 
{
  private Class<T> inputType;
  private Function<T, String> function;

  public MyFunction(Class<T> inputType, Function<T, String> function)
  {
    this.inputType = inputType;
    this.function = function;
  }

  public Class<T> getInputType()
  {
    return inputType;
  }
}