相关疑难解决方法(0)

假设我正在尝试编写一个函数来返回当前类型的实例.有没有办法T引用确切的子类型(所以T应该B在课堂上引用B)？

class A {
    <T extends A> foo();
}

class B extends A {
    @Override
    T foo();
}

我有一个表示文本片段的泛型类.该文本片段可以具有许多不同模式中的任何一种(不同类型的突出显示).这些模式由Enum表示.对于每个项目,枚举可能不同,但它必须实现一个接口,该接口提供了一种方法来组合其中两个(可以突出显示和加粗).所以我有一个界面:

public interface TextFragmentMode<E extends Enum<E>> {
    /**
     * Will combine the supplied mode with the current mode and return the
     * result.
     * 
     * @param mode The mode to combine with.
     * @return The combined mode.
     */
    public E combine( E mode );
}

然后我的TextFragment是一个文本字符串和一个模式的容器.但是当我尝试宣布这个课时:

public class TextFragment<E extends TextFragmentMode<E extends Enum<E>>> {
    StringBuilder text;
    E mode;
    ...

我收到以下错误:

令牌"extends"的语法错误,预期

根据eclipse语法突出显示,其中指的是

E extends Enum<E>

部分代码.有谁知道我做错了什么？我一定错过了关于泛型的东西......

---------------------编辑-------------------

我终于花时间阅读Josh Bloch撰写的Effective Java(第二版),结果发现他已经过了这个用例,如第34项:使用接口模拟可扩展的枚举.尽管我想说伟大的思想一样......但这样做太过于pres!

我有几个提供的接口

public interface Finder<S extends Stack<T>,T extends Item> {
    public S find(S s, int a);
}

public interface Stack<T extends Item> {
    Stack<T> getCopy();
}

和实现第一个的类:

public class SimpleFinder<S extends Stack<T>,T extends Item> implements Finder<S,T>{

    public S find(S s, int a){
         S stack = ....;
         ...
         stack = s.getCopy(); \\Error: incompatible types
                              \\       required: S
                              \\       found:    Stack<T>
        .....
        return stack;
    }


}

如果我不能改变任何接口,那么最好的做法是尽可能保持实现的通用性？

编辑 其他一些我无法破解实例化的代码, SimpleFinder<ClassA,ClassB>所以我在实现中也应该有两个泛型类型.

第二次尝试这个问题(初始代码不足以突出问题)

这是不编译的代码:

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> …