Java自限定递归类型边界接口的实现与调用方法咨询

没问题，我来帮你理清这个自限定泛型接口的逻辑，顺便给你一个能实际运行的例子！首先得点出你之前的误区：你调用a.aggregate(b)时出错，是因为aggregate方法的参数是**TResult类型**（比如你用的Integer），而不是CAgg<TResult>对象，这是对接口方法定义的误解~

先拆解一下这个接口的泛型约束：

public interface IAggregable<TElement extends IAggregable<TElement, TResult>, TResult> {
    TResult aggregate(TResult intermediateResult);
}

这里的TElement是实现该接口的类本身（也就是自限定），TResult是最终聚合结果的类型。这种设计的目的是：让接口方法只能和同类型的实例配合完成聚合，同时明确返回的结果类型。

示例1：整数求和的实现 #

我们来写一个能实际求和的实现类，思路是：

1. 类自身持有一个整数值
2. aggregate方法接收当前的中间求和结果，把自身的数值加进去，返回新的结果

代码如下：

// 先定义接口
public interface IAggregable<TElement extends IAggregable<TElement, TResult>, TResult> {
    TResult aggregate(TResult intermediateResult);
}

// 实现类：专门用于整数聚合
public class IntAggregator implements IAggregable<IntAggregator, Integer> {
    private int num;

    // 构造方法初始化数值
    public IntAggregator(int num) {
        this.num = num;
    }

    @Override
    public Integer aggregate(Integer intermediateResult) {
        // 把当前实例的数值加到中间结果上，返回新的结果
        return intermediateResult + this.num;
    }
}

调用示例 #

现在我们可以用这个类来求和了：

public class Main {
    public static void main(String[] args) {
        // 创建几个待聚合的实例
        IntAggregator num1 = new IntAggregator(5);
        IntAggregator num2 = new IntAggregator(10);
        IntAggregator num3 = new IntAggregator(15);

        // 初始聚合值设为0，依次调用每个实例的aggregate方法
        int total = 0;
        total = num1.aggregate(total); // total变成5
        total = num2.aggregate(total); // total变成15
        total = num3.aggregate(total); // total变成30

        System.out.println("总和：" + total); // 输出30
    }
}

示例2：字符串拼接的实现 #

再给你一个不同类型的例子，加深理解：

public class StringAggregator implements IAggregable<StringAggregator, String> {
    private String content;

    public StringAggregator(String content) {
        this.content = content;
    }

    @Override
    public String aggregate(String intermediateResult) {
        // 把当前实例的内容拼接到中间结果后面
        return intermediateResult + this.content;
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        StringAggregator str1 = new StringAggregator("Hello, ");
        StringAggregator str2 = new StringAggregator("Stack ");
        StringAggregator str3 = new StringAggregator("Overflow!");

        String result = "";
        result = str1.aggregate(result); // "Hello, "
        result = str2.aggregate(result); // "Hello, Stack "
        result = str3.aggregate(result); // "Hello, Stack Overflow!"

        System.out.println(result);
    }
}

再回头看你的代码问题 #

你之前写的CAgg<TResult>虽然语法上符合接口约束，但没有给类添加实际需要聚合的数据字段，而且调用时错误地把同类型对象传给了aggregate方法（它需要的是TResult类型的中间结果）。只要给类加上要聚合的属性，再在aggregate里实现具体的聚合逻辑，就能正常工作啦~

备注：内容来源于stack exchange，提问作者szubi