Java 确定泛型类型是否相等 公共A类{ 公共部门经理（目标）{ //确定T是否等于K } }

是否可以检查

和

是否是相同的类型？

仅当您有

T

的实例或传递到

A

或想要比较它们的方法中的类时，才可以检查。键入erasure…

不太可能，仅当您有

T

的实例或传递到

A

或希望比较它们的方法的类时。键入erasure…

否，最接近的选项是：

public class A<T> {
    public <K> void m(A<K> target) {
        // determine if T equals K
    }
}

公共A类{
私有类型；
公共A（类类型）{
断言类型！=null；
_类型=类型；
}
公共部门经理（目标）{
if（target！=null&&target.\u type==this.\u type）{
...
}
}

---

您可以在类型中看到传递

类作为构造函数参数的习惯用法，如。
否，最接近的方法是：

public class A<T> {
    public <K> void m(A<K> target) {
        // determine if T equals K
    }
}

公共A类{
私有类型；
公共A（类类型）{
断言类型！=null；
_类型=类型；
}
公共部门经理（目标）{
if（target！=null&&target.\u type==this.\u type）{
...
}
}

您可以在类型中看到将
类
作为构造函数参数传递的习惯用法。
这并不容易，因为javas类型擦除。在运行时，T和K的类型信息丢失

但是，如果可以获得这些类型的实例，则可以在编译时检查它们：

public class A<T> {
  private Class<T> _type;

  public A(Class<T> type) {
    assert type != null;
    _type = type;
  }

  public <K> void m(A<K> target) {
    if (target != null && target._type == this._type) {
      ...
    }
  }

公共A类{
私人T；
公共T getT（）{return T；}
公共A（T）{
t=t；
}
公共管理（目标）{
//确定T是否等于K
布尔值areEqual=t.getClass（）.equals（target.getT（）.getClass（））；
}
}

但是，这意味着您需要访问对象的实例。
这并不容易，因为javas类型擦除。在运行时，T和K的类型信息丢失

但是，如果可以获得这些类型的实例，则可以在编译时检查它们：

public class A<T> {
  private Class<T> _type;

  public A(Class<T> type) {
    assert type != null;
    _type = type;
  }

  public <K> void m(A<K> target) {
    if (target != null && target._type == this._type) {
      ...
    }
  }

公共A类{
私人T；
公共T getT（）{return T；}
公共A（T）{
t=t；
}
公共管理（目标）{
//确定T是否等于K
布尔值areEqual=t.getClass（）.equals（target.getT（）.getClass（））；
}
}

但是，这意味着您需要访问对象的实例。
以下是我编写的代码，它将告诉您类的泛型类型。使用此代码可以将类的泛型类型与目标进行比较。getClass（）

/**
*获取包含子类用于扩展泛型基的类型参数的类型类列表
*班级。
* 
*例如，如果名为ChildClass的类具有此签名：
* 
*

*公共类ChildClass扩展了ParentClass
*
* 
*然后返回的列表将有两个条目：Integer和String。
* 
*@param baseClass正在扩展的泛型基类。
*@param childClass执行扩展的子类。
*@返回类型类列表，其中包含类型参数的原始类。
*/
公共列表rawType=（类）ParameteredType.getRawType（）；
类型[]actualTypeArguments=ParameteredType.getActualTypeArguments（）；
TypeVariable[]typeParameters=rawType.getTypeParameters（）；
for（int i=0；i（）；
for（类型baseType:actualTypeArguments）{
while（resolvedTypes.containsKey（baseType））{
baseType=resolvedTypes.get（baseType）；
}
添加（getClass（baseType））；
}
返回类的类型；
}
/**
*获取类型的类。如果类型是变量类型，则返回null。
* 
*@param type获取类的类型
*@return返回类，除非Type是变量类型，否则返回null。
*/
公共类getClass（类型）{
Class returnClass=null；
if（类型instanceof Class）{
returnClass=（Class）类型；
}else if（参数化类型的instanceof）{
returnClass=getClass（（（ParameteredType）类型）.getRawType（）；
}else if（类型instanceof GenericArrayType）{
Class componentClass=getClass（（（GenericArrayType）类型）.getGenericComponentType（）；
if（componentClass！=null）{
returnClass=Array.newInstance（componentClass，0.getClass（）；
}
}
返回类；
}
以下是我编写的代码，它将告诉您类的泛型类型。使用此选项可将的泛型类型与目标进行比较。getClass（）

/**
*获取包含子类用于扩展泛型基的类型参数的类型类列表
*班级。
* 
*例如，如果名为ChildClass的类具有此签名：
* 
*

*公共类ChildClass扩展了ParentClass
*
* 
*然后返回的列表将有两个条目：Integer和String。
* 
*@param baseClass正在扩展的泛型基类。
*@param childClass执行扩展的子类。
*@返回类型类列表，其中包含类型参数的原始类。
*/
公共列表rawType=（类）ParameteredType.getRawType（）；
类型[]actualTypeArguments=ParameteredType.getActualTypeArguments（）；
TypeVariable[]typeParameters=rawType.getT
public abstract class A<T> {

    private Type type;

    public A() {
        Type superclass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
    }

    public <K> void m(A<K> target) {
            System.out.println( type.equals( target.type ) );
    }
}

    A<String> as = new A<String>(){};
    A<String> a2s = new A<String>(){};
    A<Integer> ai = new A<Integer>(){};

    as.m(a2s); // prints true
    as.m(ai);  // prints false