第二次尝试这个问题(初始代码不足以突出问题)
这是不编译的代码:
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);
}
}
混合泛型和原始类型是行不通的.如果您需要这些接口相互引用,它们还需要引用自己:
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);
}
虽然这看起来很像头发,但我不确定你为什么需要它.
编辑:
我能够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);
}
}
这个问题似乎是每个通用声明XGame和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);
}
}
这里的关键是宣布一个抽象的方法self()在AbstractGame返回类型的实例G.扩展类必须使用自己的类型解析继承的类型参数,并实现self()返回this.这仅适用于内部代码,因为扩展类很容易存在,例如:
public class EvilGame extends AbstractGame<Integer, AnotherGame> { ... }