泛型类型为自引用类型的Java子类化问题 import java.util.*； //让我们定义一个自引用类型： 类自引用{} //自引用的完整（即未参数化）子类型： 类subassa扩展了自引用{} //自引用的部分（即参数化）子类型： 类子类B扩展自引用{} //子类B的两个完整亚型 子类B1扩展子类B{} 子类B2扩展子类B{} //现在，让我们在自引用上定义一个泛型类型： 类泛型{} //为a、B1或B2创建子类型没有问题 类GenericA扩展了泛型{} 类GenericB1扩展了泛型{} 类GenericB2扩展了泛型{} //我们还可以为扩展子类B的特定类型定义参数化类型 类GenericB扩展了Generic{} //但是，似乎不可能为任何子类的子类定义泛型的非参数化子类 //我的目标是为GenericB>提供一个类型别名，以避免 //必须在代码中到处提到它。这类似于使用提供ArrayList的别名 类ArrayListOffString扩展了ArrayList{} //未成功的尝试： //类GenericAnyB扩展泛型{}//错误：绑定不匹配 //类GenericAnyB扩展了Generic>{}//错误：无效语法：超类型不能指定任何通配符 //类GenericAnyB扩展了Generic

您是对的，这是不可能的，就像在没有通配符或原始类型的情况下声明具有自引用类型的变量是不可能的一样。您将无法直接实例化

子类b

，原因与在没有自引用类型参数的情况下无法将其用作绑定相同

有关此限制的更多讨论，请参阅本文：

底线是

GenericAnyB

本身需要是泛型的，才能使用

子类b

作为边界：

import java.util.*;

// Let's define a self-referential type:
class SelfReferential<T extends SelfReferential<T>> {}

//A complete (i.e. not parameterized) subtype of SelfReferential:
class SubclassA extends SelfReferential<SubclassA> {}

//A partial (i.e. parameterized) subtype of SelfReferential:
class SubclassB<T extends SubclassB<T>> extends SelfReferential<T> {}

//Two complete subtypes of SubclassB
class SubclassB1 extends SubclassB<SubclassB1> {}    
class SubclassB2 extends SubclassB<SubclassB2> {}

//Now let's define a generic type over SelfReferential:
class Generic<T extends SelfReferential<T>> {}

//No problem creating a subtype for A, B1 or B2
class GenericA extends Generic<SubclassA> {}   
class GenericB1 extends Generic<SubclassB1> {}    
class GenericB2 extends Generic<SubclassB2> {}

//We can also defined a parameterize type for specific types extending SubclassB
class GenericB<T extends SubclassB<T>> extends Generic<T> {}

//However, it does not seem possible to define a non-parameterized subtype of Generic of ANY subtype of SublassB
//My goal is to provide a type alias for GenericB<? extends SubclassB<?>> to avoid 
//having to mention it everywhere in the code. This is like providing an alias for ArrayList<String> using 
class ArrayListOfString extends ArrayList<String> {}

//Unsucessful attempts:
//class GenericAnyB extends Generic<SubclassB> {} //ERROR: bound mismatch
//class GenericAnyB extends Generic<SubclassB<?>> {} //ERROR: bound mismatch
//class GenericAnyB extends Generic<? extends SubclassB<?>> {} //ERROR: invalid syntax: a supertype cannot specify any wildcard
//class GenericAnyB extends Generic<SubclassB<? extends SubclassB>> {} //ERROR: bound mismatch
//class GenericAnyB extends Generic<SubclassB<SubclassB<SubclassB<SubclassB<SubclassB<SubclassB>>>>>> {} // well...
//class GenericAnyB extends <T extends SubclassB<T>> Generic<T> {} //ERROR: this syntax is illegal

类GenericAnyB扩展了Generic{}

这只是在层次结构中添加了一个额外的步骤，然后才可以使用：

class GenericAnyB<T extends SubclassB<T>> extends Generic<T> { }

类GenericB1扩展了GenericAnyB{}
类GenericB2扩展了GenericAnyB{}

class GenericB1 extends GenericAnyB<SubclassB1> { }   
class GenericB2 extends GenericAnyB<SubclassB2> { }