我有事情(比如,上下文,数字),可以对自己的类型执行操作：
interface Number<N> {
N add(N to);
}
class Int implements Number<Int> {
Int add(Int to) {...}
}
以及对某一上限的所有亚型采取行动的行为者：
interface Actor<U> {
<E extends U> E act(Iterable<? extends E> items);
}
我想让一个演员在任何数值类型上进行多态：
class Sum implements Actor<Number> {
<N extends Number<N>> N act(Iterable<? extends N> items) {...}
}
现在,显然这不起作用,因为Number和Number< N>是不一样的实际上,由于Number不会将实现者的type参数限制为自己的类型,所以这样的actor不可能工作.但是我并不在乎对数字的操作一般 – 我很满意我的功能只能工作在某些类型的数字N扩展Number< N>
作为替代,我可以声明：
interface Actor<E> {
E act(Iterable<? extends E> items);
}
class Sum<N extends Number<N>> implements Actor<N> {
N act(Iterable<? extends N> items) {...}
}
但是这对我来说并不奏效,因为当我构建我的总和时,我迫使我知道N,我的用例不方便.它还强制一个丑陋的< N扩展的Number N>在每个使用Sum的类或方法中,引起类型杂乱的扩散.
有什么优雅的方式来做我想要的吗？
例：
以下是一些示例代码,表达我想做的事情.
interface Folder<U> {
<E extends U> E fold(Iterable<? extends E> items);
}
class Sum implements Folder<Number> {
<N extends Number<N>> N fold(Iterable<? extends N> items) {
Iterator<? extends N> iter = items.iterator();
N item = iter.next();
while (iter.hasNext())
item = item.add(iter.next());
return item;
}
}
class Concat implements Folder<String> {
<S extends String> fold(Iterable<? extends S> items) {
StringBuilder concatenation = new StringBuilder();
for (S item : items)
concatenation.append(item);
return concatenation.toString();
}
}
class FoldUtils {
static <U,E extends U> E foldDeep(Folder<U> folder,Iterable<? extends Iterable<? extends E>> itemses) {
Collection<E> partialResults = new ArrayList<E>();
for (Iterable<? extends E> items : itemses)
partialResults.add(folder.fold(items));
return folder.fold(partialResults);
}
}
解决方法
看一下你的例子,我不知道从通用方法中提供具体的参数,而不是让它在演员中获得什么：
class Sum<T extends Number<T>> implements Actor<T> {
T act(Iterable<? extends T> items) {...}
}
有一个Sum< any-self-refferential-Number>的优点是什么？ vs只有Sum< Int>和Sum< Float>等等
如果您担心创建不同实例的微小内存开销,那么每次返回相同的实例时,都可以使用未经检查的转换,如通常那样安全(参见例如Guava的Optional.absent()或Collections.emptyList()) .
在你的例子中,有人最终必须基本上做：
List<List<Int>> list; foldDeep(new Sum(),list)
那么为什么不要求类型参数呢？
foldDeep(new Sum<Int>(),list)
或者如果封装在工厂后面,
foldDeep(Sum.instance(),list) foldDeep(NumberFolders.sum(),list)
总之,我不清楚为什么这样也不会奏效：
interface Folder<U> {
U fold(Iterable<? extends U> items);
}
class Sum<T extends Number<T>> implements Folder<T> {
public T fold(Iterable<? extends T> items) {
//...
}
}
class FoldUtils {
static <E> E foldDeep(Folder<E> folder,Iterable<? extends Iterable<? extends E>> itemses) {
Collection<E> partialResults = new ArrayList<>();
for (Iterable<? extends E> items : itemses)
partialResults.add(folder.fold(items));
return folder.fold(partialResults);
}
}
//...
FoldUtils.foldDeep(new Sum<>(),list);
