Java 如何定义自引用类型的上限？

我有一些东西（比如，上下文、数字）可以对自己的类型执行操作：

interface Number<N> {
    N add(N to);
}
class Int implements Number<Int> {
    Int add(Int to) {...}
}

但这对我来说不起作用，因为它迫使我在构建我的

总和时知道
N
，这是我的用例不允许的。它还强制对每个多态使用求和的类或方法使用丑陋的
，从而导致类型混乱

有什么优雅的方式来做我想做的事吗

例子：
下面是一些示例代码，表达了我想做的事情

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

接口文件夹{
E fold（Iterable看看你的例子，我不确定你从让泛型方法提供具体参数和让它在actor中得到什么好处：

class Sum<T extends Number<T>> implements Actor<T> {
    T act(Iterable<? extends T> items) {...}
}

那么为什么不在那里只需要type参数呢

foldDeep(new Sum<Int>(), 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);

接口文件夹{
U fold（IterableCan）您可以添加一些不应该也应该编译的示例吗？这将有助于创建一个更大的图景。当然，我将很快尝试添加这些示例。乍一看，我怀疑这需要更高种类的类型，而Java不支持这些类型。另请参阅
class Sum<T extends Number<T>> implements Actor<T> {
    T act(Iterable<? extends T> items) {...}
}

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