有两种方法可以做到这一点，但我都不推荐。
方法一：泛型
具体来说，递归的（指回泛型类本身）：
public class ClassA<R extends ClassA<R>> { // note the recursive nature
public ArrayList<String> v1 = new ArrayList<>();
@SuppressWarnings("unchecked")
protected R self() {
return (R) this;
}
public R addOnce(String s1) {
v1.add(s1);
return self();
}
}
如果您不喜欢 SuppressWarnings（而且您不应该这样做！它们可以隐藏错误），您可以通过创建一个 abstract class AbstractClassA 来解决这个问题，每个子类都覆盖一个 protected abstract R self()：
// AbstractClassA looks like ClassA above; it contains addOnce
class ClassA extends AbstractClassA<ClassA> {
@Override
public ClassA self() {
return this;
}
}
class ClassB extends AbstractClassA<ClassB> {
ClassB addTwice(String s2) {
...
return this;
}
}
这确实意味着您的大多数用例将使用通配符 AbstractClassA<?> 类型。除了丑陋之外，如果您尝试序列化这些实例，这会变得很麻烦。 AbstractClassA.class 返回一个Class<AbstractClassA>，不是一个Class<AbstractClassA<?>>，可以是force you to do more unchecked casts。
另外，AbstractClassA 的子类不继承 <R> 类型，所以如果你想定义保持模式的新方法（例如在 ClassB 中），你必须使用新的通用参数重复该模式。我的预测是你会后悔的。
方法二：覆盖每个方法
另一种方法是手动覆盖基类中的所有方法。当你重写一个方法时，你can have it return a subclass of the original method's return type。所以：
public class ClassA {
public ArrayList<String> v1 = new ArrayList<>();
public ClassA addOnce(String s1) {
v1.add(s1);
return this;
}
}
public class ClassB extends ClassA {
public ClassB addOnce(String s2) {
super.addOnce(s2);
return this; // same reference as in the super method, but now typed to ClassB
}
...
}
这种方法没有任何隐藏的陷阱，就像第一种方法一样。它就像你想象的那样工作。这只是一种痛苦，这意味着每次将方法添加到 ClassA 时，如果您希望事情继续工作，您也必须将该方法添加到 ClassB（和 ClassC 等）。如果您无法控制 ClassB/C/etc（例如，如果您正在发布 API），那么这可能会出现问题，并使您的 API 感觉不成熟。
方法三：首先从更具体的子类开始链
这不是您问题的真正答案，而是解决相同问题的模式。这个想法是让 ClassA 和 ClassB 保持原样，但始终首先调用 ClassB 的方法：
new ClassB().addTwice("2").addOnce("1");
这种方法效果很好，但有点尴尬。大多数时候，人们的想法是首先在基类上设置东西，然后在子类上设置子类特定的东西。如果您可以扭转这种情况，并且您真的想要这些链接方法，那么这可能是我会选择的方法。但我真正的建议是：
我的建议：算了
Java 只是不能很好地处理这些类型的方法链。我建议你忘记整件事，不要试图在这一点上与语言抗争。使方法返回void 并将每个调用放在自己的行上。在使用尝试过第一种和第三种方法的代码后，我发现它周围的丑陋很快就会变老，而且通常比它的价值更痛苦。 （我从来没有见过第二种方法有效，因为它太痛苦了，没有人想尝试它。:)）