周期性仿制药（试行2）

Question

在this问题的第二次尝试（初始密码是不够的，突出的问题）

这里是不编译代码：

interface Player<R, G extends Game> 
{ 
    R takeTurn(G game); 
} 

interface Game<P extends Player> 
{ 
    void play(P player); 
} 

abstract class AbstractGame<R, P extends Player> 
    implements Game<P> 
{ 
    public final void play(final P player) 
    { 
     final R value; 

     value = player.takeTurn(this); 
     turnTaken(value); 
    } 

    protected abstract void turnTaken(R value); 
} 

public class XPlayer 
    implements Player<Integer, XGame> 
{ 
    @Override 
    public Integer takeTurn(final XGame game) 
    { 
     return (42); 
    } 
} 

public class XGame<P extends Player<Integer, XGame>> 
    extends AbstractGame<Integer, XPlayer> 
{ 
    @Override 
    protected void turnTaken(final Integer value) 
    { 
     System.out.println("value = " + value); 
    } 
} 

public class Main 
{ 
    public static void main(final String[] argv) 
    { 
     final XPlayer player; 
     final XGame game; 

     player = new XPlayer(); 
     game = new XGame(); 
     game.play(player); 
    } 
} 

我是什么碰到的是试图让AbstractGame中的play方法编译。看起来我必须在游戏和玩家的圈子中加入泛型才能扩展/实现，但对于我来说，我无法得到它。

这个play方法在AbstractGame类中必须是最终的，并且没有办法进行转换，并且我不想编写像turnTaken之类的另一个方法来让它工作，如果我没有至。

编辑：这里要求的是，编译代码，但需要投：

interface Player<R, P extends Player<R, P, G>, G extends Game<R, G, P>> 
{ 
    R takeTurn(G game); 
} 

interface Game<R, G extends Game<R, G, P>, P extends Player<R, P, G>> 
{ 
    void play(P player); 
} 

abstract class AbstractGame<R, G extends Game<R, G, P>, P extends Player<R, P, G>> 
    implements Game<R, G, P> 
{ 
    public final void play(final P player) 
    { 
     final R value; 

     value = player.takeTurn((G)this); 
     turnTaken(value); 
    } 

    protected abstract void turnTaken(R value); 
} 

class XPlayer 
    implements Player<Integer, XPlayer, XGame> 
{ 
    @Override 
    public Integer takeTurn(final XGame game) 
    { 
     return (42); 
    } 
} 

class XGame 
    extends AbstractGame<Integer, XGame, XPlayer> 
{ 
    @Override 
    protected void turnTaken(final Integer value) 
    { 
     System.out.println("value = " + value); 
    } 
} 

class Main 
{ 
    public static void main(final String[] argv) 
    { 
     final XPlayer player; 
     final XGame game; 

     player = new XPlayer(); 
     game = new XGame(); 
     game.play(player); 
    } 
} 

Answer 1

混合仿制药和原种是行不通的。如果你需要这些接口来相互引用，他们也需要引用自己：

interface Player<R, P extends Player<R, P, G>, G extends Game<R, G, P>> 
{ 
    R takeTurn(G game); 
} 

interface Game<R, G extends Game<R, G, P>, P extends Player<R, P, G>> 
{ 
    void play(P player); 
} 

虽然这看起来有点hairbrained，我不知道为什么你需要它。

编辑：

我能实现你AbstractGame基于以上：

abstract class AbstractGame<R, P extends Player<R, P, AbstractGame<R, P>>> 
    implements Game<R, AbstractGame<R, P>, P> 
{ 
    public final void play(final P player) 
    { 
     final R value; 

     value = player.takeTurn(this); 
     turnTaken(value); 
    } 

    protected abstract void turnTaken(R value); 
} 

但是我不能完全与XGame和XPlayer闭合电路：

public class XGame 
    extends AbstractGame<Integer, XPlayer> //compile error on XPlayer 
{ 

    protected void turnTaken(Integer value) { } 
} 

public class XPlayer 
    implements Player<Integer, XPlayer, XGame> //compile error on XGame 
{ 
    @Override 
    public Integer takeTurn(final XGame game) 
    { 
     return (42); 
    } 
} 

这个问题似乎是的每个通用声明和XPlayer需要另一个是正确的。这是您的设计真正具有周期性的地方。如果编译器'假设'每一个都是正确的，那理论上就是可行的。但事实并非如此。

编辑2：

如何：

interface Game<R, G extends Game<R, G>> 
{ 
    void play(Player<R, G> player); 
} 

interface Player<R, G extends Game<R, G>> 
{ 
    R takeTurn(G game); 
} 

abstract class AbstractGame<R, G extends AbstractGame<R, G>> 
    implements Game<R, G> 
{ 
    public final void play(final Player<R, G> player) 
    { 
     final R value; 

     value = player.takeTurn(self()); 
     turnTaken(value); 
    } 

    protected abstract G self(); 

    protected abstract void turnTaken(R value); 
} 

public final class XGame extends AbstractGame<Integer, XGame> 
{ 
    protected XGame self() { 
     return this; 
    } 

    protected void turnTaken(Integer value) { } 
} 

public class XPlayer implements Player<Integer, XGame> 
{ 
    @Override 
    public Integer takeTurn(final XGame game) 
    { 
     return (42); 
    } 
} 

这里的关键是在AbstractGame返回G类型的实例声明了一个抽象方法self()。扩展类必须使用它们自己的类型来解析继承的类型参数，并执行self()以返回this。这仅适用于内部代码，因为延伸类很容易撒谎，例如：

public class EvilGame extends AbstractGame<Integer, AnotherGame> { ... } 

见我的回答here和this post有关这种模式的更多细节。

Answer 2

正如Paul Bellora指出的那样，您正在混合通用和原始类型 - 而正确的，完全通用的解决方案有点混乱，需要大量冗余。没有好的方法（我知道）在Java中做循环（而不是递归）泛型。

，而不是为此而努力，我会做的只有一个参数都Player和Game通用，值的类型被打了 - 你有什么作为R。

interface Game<R> { 
    void play(Player<? extends R> player); 
} 

interface Player<R> { 
    R takeTurn(Game<? super R> game); 
} 

abstract class AbstractGame<R> implements Game<R> { 
    public final void play(Player<? extends R> player) { 
     final R value; 

     value = player.takeTurn(this); 
     turnTaken(value); 
    } 

    protected abstract void turnTaken(R value); 
} 

class XPlayer implements Player<Integer> { 
    @Override 
    public Integer takeTurn(Game<? super Integer> game) { 
     return 42; 
    } 
} 

class XGame extends AbstractGame<Integer> { 
    @Override 
    public void turnTaken(Integer value) { 
     System.out.println("value = " + value); 
    } 
} 

public class Main { 
    public static void main(String[] argv) { 
     XPlayer player = new XPlayer(); 
     XGame game = new XGame(); 
     game.play(player); 
    } 
} 

现在，谁知道如何采取R基于移动可以发挥任何R基于游戏的任何球员。