从一个没有混乱的接口实现泛型方法？

Question

在实现这样的接口时，有什么方法可以避免将所有类型添加到类定义中的混乱？

MyInterface.java

import java.util.List;
abstract class BaseA {}
abstract class BaseB {}
abstract class BaseC {}

interface MyInterface<T extends BaseA, U extends BaseB, V extends BaseC> {
    public void foo( List<? extends T> list );
    public void bar( List<? extends U> list );
    public void baz( List<? extends V> list );
} 

MyImplementation.java

/* Some concrete implementations of the abstract classes used in the interface */
class A extends BaseA{}
class B extends BaseB{}
class C extends BaseC{}

class MyImplementation implements MyInterface<A,B,C> {
    public void foo( List<? extends A> list){}
    public void bar( List<? extends B> list){}
    public void baz( List<? extends C> list){}
}

我不喜欢的是我发现特定于方法的东西，例如参数的类型，与类声明混合在一起。在这种情况下，对于接口中的每个泛型方法，我必须在“括号部分”中添加一个正式类型。

是否有另一种方法来实现上述（强制实现的调用者在接口中使用参数类的特定子类）而不会出现所有“混乱”？

我对泛型不太感兴趣，上面的代码基本上是基于对这个question的回答。

Answer 1

这就是泛型的工作原理，但是如果您发现自己添加到一个很长的类型列表中，您可能会重新考虑您的设计。在这种情况下（实际上并不知道代码的用途），我会进一步概括接口：

abstract class PlayBase {}
interface MyInterface<T extends PlayBase> {
    public void playWith(List<T> list);
}   

...和一个示例实现：

class A extends PlayBase {}
class MyImplementationA implements MyInterface<A> {
    public void playWith(List<? extends A> list){}
}

这种方式设计更容易以一种很好的方式更改类型（无需更改界面）。

Answer 2

这个怎么样：

interface MyInterface {
    public <T extends BaseA> void playWithA( List<? extends T> list );
    public <U extends BaseB> void playWithB( List<? extends U> list );
    public <V extends BaseC> void playWithC( List<? extends V> list );
}