(我使用的是 Eclipse Luna 4.4.0，JDK 1.8.0_05)

我在做一个游戏，游戏世界的拓扑结构大致可以分解为World -> Level -> Tile，其中Tile是地形的一个小单元。我设置了三个项目，一个包含这些结构的一些基类，另外两个是服务器和客户端，它们扩展基础项目中的结构以获得每个项目需要的额外内容。像这样:

基础项目:

public class BaseWorld{/* ...code... */}
public class BaseLevel{/* ...code... */}
public class BaseTile{/* ...code... */}

在服务器和客户端项目中:

public class World extends BaseWorld{/* ...extended code... */}
public class Level extends BaseLevel{/* ...extended code... */}
public class Tile extends BaseTile{/* ...extended code... */}

现在在基础项目的许多部分，有返回基类的方法，但在服务器和客户端项目中，这通常意味着我必须重写方法并转换为子类型，因为子项目独占使用子类型。像这样:

public class BaseLevel{
  BaseLevel getNextLevel(){/* ...code... */}
}

public class Level extends BaseLevel{
  Level getNextLevel(){
    return (Level)super.getNextLevel();
  }
}

维护起来有点痛苦。我发现我可以使用泛型来解决其中的一些问题，模式如下:

public class BaseLevel<Level extends BaseLevel<Level>>{
  Level getNextLevel(){/* ...code... */}
}

public class Level extends BaseLevel<Level>{
  //All sorted! getNextLevel() already returns this subclass type.
}

好吧，我有一个疯狂的想法，将上述模式弯曲到极限，并且能够在所有父类(super class)中的任何地方使用所有子类。现在我必须说，我绝不认可以下代码是好的编程，我只是有想法并尽可能地使用它，只是为了看看它会如何工作。不管怎样，我想出了以下怪诞的东西。

public class BaseWorld<Tile extends BaseTile<Tile, Level, World>
                      ,Level extends BaseLevel<Tile, Level, World>
                      ,World extends BaseWorld<Tile, Level, World>>{
  /* ...code... */
}

public class BaseLevel<Tile extends BaseTile<Tile, Level, World>
                      ,Level extends BaseLevel<Tile, Level, World>
                      ,World extends BaseWorld<Tile, Level, World>>{
  /* ...code... */
}

public class BaseTile<Tile extends BaseTile<Tile, Level, World>
                 ,Level extends BaseLevel<Tile, Level, World>
                 ,World extends BaseWorld<Tile, Level, World>>{
  /* ...code... */
}

现在，无论何时我需要从任何其他类返回任何类，我都可以在子项目中不使用任何类型转换!

很遗憾，不是，因为当 Eclipse 重建工作区时:

A stack overflow error has occurred.
You are recommended to exit the workbench. [...]

我想当一个类的泛型被解析时，它必须去解析另一个类的泛型，然后陷入递归循环。

提问时间:

这个错误是Eclipse编辑器中风了，还是java编译器问题？

上面的内容不会在编辑器中突出显示为编译器警告/错误 - 应该是，即使它在技术上看起来是有效的？

这个递归可能无限深，还是非常深？

是否有可能在避免此错误的同时实现我在这里尝试的目标？ (我再次强调，这绝对不是一个好的模式，我只是想知道它是否可行)

最佳答案

是Eclipse编辑器中风了，还是java编译器？

本例中的 Eclipse 编辑器。以下声明一起(当然在不同的文件中)是有效的 Java 代码。

public class BaseFoo<F extends BaseFoo<F,B>, B extends BaseBar<F,B>> {}
public class BaseBar<F extends BaseFoo<F,B> ,B extends BaseBar<F,B>> {}
public class Foo<F extends BaseFoo<F,B>,B extends BaseBar<F,B>> extends BaseFoo<F,B> {}
public class Bar<F extends BaseFoo<F,B>,B extends BaseBar<F,B>> extends BaseBar<F,B> {}

以上内容不会在编辑器中作为编译器警告/错误突出显示 - 是否应该突出显示，即使它在技术上看起来是有效的？

它可能应该(好吧，好吧，好吧，我在这里开玩笑......)不。这是有效的 Java。只是……嗯……

这个递归可能无限深，还是非常深？

无限，我在这里猜测(稍后会详细介绍我的猜测)。

考虑尝试实例化 Foo 的实例。

继续，使用默认构造函数编写初始化程序。

Foo<Foo, Bar> foo = new Foo<Foo, Bar>();

关于通用边界不匹配，这里有四个错误。

让我们尝试解决它。

Foo<Foo<Foo,Bar>, Bar<Foo,Bar>> foo = new Foo<Foo<Foo,Bar>, Bar<Foo,Bar>>();

现在有 12 个错误。我们可以永远尝试初始化它。

是否可以在避免此错误的同时实现我在这里尝试的目标？ (我再次强调，这绝对不是一个好的模式，我只是想知道它是否可以工作)

考虑以下基本结构:

class World {
    SomeCollection<Level> levels;
}

class Level {
    SomeCollection<Tile> tiles;
}

class Tile { }

为什么？

上面代码的基本结构比较喜欢composition over inheritance ，并且不使用泛型，除了一些内置的泛型集合类型。这为您提供的初始化样式的一个很好的例子是静态构建器，最终编写类似这样的东西来初始化 World:

World gameWorld = new World.Builder().
                 .loadLevels(levelSource)
                 .loadTiles(tileset)
                 .build();

希望对您有所帮助。

结束语

不要继续。这是可能解决您的问题的探索路径。不要再去这里了。

关于java - 这个复杂的泛型模式会导致 Eclipse 崩溃——我能让它工作吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25458729/