Java 如何对多个耦合对象使用泛型？

所以我很难找到合适的设计

我的应用程序有两个控制状态的关键对象，它们需要相互交互：ItemList和ItemState。它们都依赖于一个通用的ITEM_类型，因此可以在不同的上下文中运行。它们也是抽象的，以允许项类型相关的行为

这两个部分都需要知道泛型类型，而且，由于它们彼此交谈，因此它们需要知道彼此的泛型类型。（ItemList实例需要知道其ItemState字段是ItemState，反之亦然）

我目前的解决方案可行，但似乎很糟糕。一定有更好的办法。这就是我现在正在做的：

public abstract class ItemState<
  ITEM_TYPE,
  STATE_TYPE extends ItemState<ITEM_TYPE, STATE_TYPE, LIST_TYPE>,
  LIST_TYPE extends ItemList<ITEM_TYPE, STATE_TYPE, LIST_TYPE>> {

}
public abstract class ItemList<
  ITEM_TYPE,
  STATE_TYPE extends ItemState<ITEM_TYPE, STATE_TYPE, LIST_TYPE>,
  LIST_TYPE extends ItemList<ITEM_TYPE, STATE_TYPE, LIST_TYPE>> {

}

公共抽象类ItemState<
项目类型：，
状态\类型扩展了ItemState，
列表\类型扩展项目列表>{
}
公共抽象类项目列表<
项目类型：，
状态\类型扩展了ItemState，
列表\类型扩展项目列表>{
}

然后，实现类可能如下所示：

class StringState extends ItemState<String, StringState, StringList> {

}
class StringList extends ItemList<String, StringState, StringList> {

}

类StringState扩展了ItemState{
}
类StringList扩展了ItemList{
}

请注意，对于ItemState，STATE\u TYPE是对实现类的引用，对于ItemList/LIST\u TYPE也是如此

实际上，如果我只是将ItemState作为ItemList的一个内部类，我的问题就会得到解决，因为会有一个隐式绑定，它们可以共享泛型声明，但这两个类都非常大且独立，所以我不希望这样做

有什么建议吗

编辑：作为注释的反例：

public abstract class ItemState<ITEM_TYPE> {  
  public abstract ItemList getItemList();  
  public void doSomething() {
    // This should not compile because abstract super class has
    // no idea what the generic type of getItemList() is
    ITEM_TYPE item = this.getItemList.getItem(); 
  }  
}

公共抽象类ItemState{
公共抽象ItemList getItemList（）；
公共无效剂量测定法（）{
//这不应该编译，因为抽象超类
//不知道getItemList（）的泛型类型是什么
ITEM_TYPE ITEM=this.getItemList.getItem（）；
}  
}

编辑2：我认为我能想到的最好的解决方案就是让ItemList/ItemState以某种方式继承，这样它们就可以像同一个类一样工作。我不喜欢这个解决方案，因为它覆盖了关注点的分离，但它使泛型更易于管理

旁注：我的实际应用程序有4个相互交织的类，为了简单起见，我只使用了2个。实际上，泛型太糟糕了，以至于无法理解，很难重构（每个类只有4行泛型声明）。我现在已经将这4个类组成了一个垂直继承层次结构

---

JM Yang的解决方案非常好

我认为在声明这两个类时，您可以只引用泛型类型ITEM_type

我能够编译下面的代码，没有错误

public abstract class ItemList<ITEM_TYPE> {
    public abstract ItemState<ITEM_TYPE> getState();

    public abstract ITEM_TYPE getItem();
}

public abstract class ItemState<ITEM_TYPE> {
    public abstract ItemList<ITEM_TYPE> getItemList();

    public void doSomething() {
        ITEM_TYPE item = getItemList().getItem();
        System.out.println(item);
    }
}

public class StringList extends ItemList<String> {
    @Override
    public StringState getState() {
        return new StringState();
    }

    @Override
    public String getItem() {
        return "";
    }
}

public class StringState extends ItemState<String> {
    @Override
    public StringList getItemList() {
        return new StringList();
    }
}

公共抽象类ItemList{
公共抽象项状态getState（）；
公共抽象项_TYPE getItem（）；
}
公共抽象类ItemState{
公共抽象ItemList getItemList（）；
公共无效剂量测定法（）{
ITEM_TYPE ITEM=getItemList（）.getItem（）；
系统输出打印项次（项）；
}
}
公共类StringList扩展了ItemList{
@凌驾
公共字符串状态getState（）{
返回新的StringState（）；
}
@凌驾
公共字符串getItem（）{
返回“”；
}
}
公共类StringState扩展了ItemState{
@凌驾
公共StringList getItemList（）{
返回新的StringList（）；
}
}

这对我来说似乎没问题，似乎没有其他方法可以做到这一点。是的，泛型语法很糟糕！我已经更新了示例代码以包含doSomething（）的实现。问题是，在抽象基类中工作时，无法判断耦合对象是否具有相同的类型。请您用一个示例详细说明一下，正如您在我的代码中看到的，在抽象类ItemList中，使用ItemState可确保耦合对象具有相同的类型，在抽象类ItemState中，使用ItemList的目的相同。可以这样编写：公共抽象类ItemState{public abstract ItemList getItemList（）；public void doSomething（）{ITEM_type ITEM=this.getItemList.getItem（）；哦，等等，这确实有效。这绝对是一个更好的解决方案。当每个子类确实应该在父类中定义时，您必须为每个子类重写该方法，这仍然是一个难题。哦，好吧。。。。