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 );
}

从界面实现泛型方法而不杂乱？

2 个答案: