总结:

它被称为“流畅接口”或“方法链接”。 这不是“标准”Java，尽管你现在看到的越来越多(在jQuery中工作得很好) 它违反了JavaBean规范，因此它将与各种工具和库分开，特别是JSP构建器和Spring。 它可能会阻止JVM通常会做的一些优化 一些人认为它能清理代码，另一些人认为它“可怕”

还有一些没有提到的要点:

This violates the principal that each function should do one (and only one) thing. You may or may not believe in this, but in Java I believe it works well. IDEs aren't going to generate these for you (by default). I finally, here's a real-world data point. I have had problems using a library built like this. Hibernate's query builder is an example of this in an existing library. Since Query's set* methods are returning queries, it's impossible to tell just by looking at the signature how to use it. For example: Query setWhatever(String what); It introduces an ambiguity: does the method modify the current object (your pattern) or, perhaps Query is really immutable (a very popular and valuable pattern), and the method is returning a new one. It just makes the library harder to use, and many programmers don't exploit this feature. If setters were setters, it would be clearer how to use it.

这一点也不坏。但是它与JavaBeans Spec不兼容。

有很多规范依赖于这些标准访问器。

你总能让它们共存。

public class Some {
    public String getValue() { // JavaBeans
        return value;
    }
    public void setValue(final String value) { // JavaBeans
        this.value = value;
    }
    public String value() { // simple
        return getValue();
    }
    public Some value(final String value) { // fluent/chaining
        setValue(value);
        return this;
    }
    private String value;
}

现在我们可以一起用了。

new Some().value("some").getValue();

下面是另一个版本的不可变对象。

public class Some {

    public static class Builder {

        public Some build() { return new Some(value); }

        public Builder value(final String value) {
            this.value = value;
            return this;
        }

        private String value;
    }

    private Some(final String value) {
        super();
        this.value = value;
    }

    public String getValue() { return value; }

    public String value() { return getValue();}

    private final String value;
}

现在我们可以这么做了。

new Some.Builder().value("value").build().getValue();

一般来说，这是一个很好的实践，但是你可能需要使用布尔类型来确定操作是否成功完成，这也是一种方法。一般来说，没有教条说这是好的还是床上的，它当然来自于情况。

我更喜欢使用“with”方法:

public String getFoo() { return foo; }
public void setFoo(String foo) { this.foo = foo; }
public Employee withFoo(String foo) {
  setFoo(foo);
  return this;
}

因此:

list.add(new Employee().withName("Jack Sparrow")
                       .withId(1)
                       .withFoo("bacon!"));

警告:此withX语法通常用于为不可变对象提供“setter”，因此这些方法的调用者可能合理地期望它们创建新对象，而不是改变现有实例。也许更合理的措辞应该是:

list.add(new Employee().chainsetName("Jack Sparrow")
                       .chainsetId(1)
                       .chainsetFoo("bacon!"));

使用chainsetXyz()命名约定，几乎每个人都应该满意。

它不仅打破了getter /setter的惯例，还打破了Java 8方法参考框架。MyClass::setMyValue是一个BiConsumer<MyClass,MyValue>， myInstance::setMyValue是一个Consumer<MyValue>。如果你让你的setter返回这个，那么它就不再是Consumer<MyValue>的有效实例，而是Function<MyValue,MyClass>，并且会导致任何使用这些setter的方法引用(假设它们是void方法)的事情中断。

我不懂Java，但我用c++做过。 也有人说这会让文字变得很长，很难读懂， 但我这样做过很多次:

list.add(new Employee()
    .setName("Jack Sparrow")
    .setId(1)
    .setFoo("bacon!"));

这个更好:

list.add(
    new Employee("Jack Sparrow")
    .Id(1)
    .foo("bacon!"));

至少我是这么认为的。但如果你愿意，欢迎你给我投反对票，称我为糟糕的程序员。我不知道Java中是否允许这样做。