我有一些东西(比如,对于上下文,数字)可以对它们自己的类型执行操作:
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);
}
我想制作一个对任何数字类型进行多态操作的 actor:
class Sum implements Actor<Number> {
<N extends Number<N>> N act(Iterable<? extends N> items) {...}
}
现在,显然这行不通,因为 Number
和 Number<N>
不一样。事实上,自 Number
不将实现者的类型参数限制为它自己的类型,这样的参与者不可能工作。但我不关心对 Number
进行操作总的来说 - 我很满意我的功能只适用于某种类型的数字 N extends 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
当我构建我的 Sum
时,我的用例不允许这样做。它还迫使一个丑陋的<N extends 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);
}
}
最佳答案
看看你的例子,我不确定你通过泛型方法提供具体参数与在 actor 中提供具体参数有什么好处:
class Sum<T extends Number<T>> implements Actor<T> {
T act(Iterable<? extends T> items) {...}
}
拥有 Sum<any-self-referential-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);
关于java - 如何限制自引用类型?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/24833822/