如果可用，最好使用其他语言结构。例如，在Kotlin中，您可以使用with、apply或let。如果使用这种方法，实际上不需要从setter返回实例。

这种方法允许你的客户端代码:

对返回类型漠不关心 更容易维护 避免编译器的副作用

这里有一些例子。

val employee = Employee().apply {
   name = "Jack Sparrow"
   id = 1
   foo = "bacon"
}


val employee = Employee()
with(employee) {
   name = "Jack Sparrow"
   id = 1
   foo = "bacon"
}


val employee = Employee()
employee.let {
   it.name = "Jack Sparrow"
   it.id = 1
   it.foo = "bacon"
}

总结:

它被称为“流畅接口”或“方法链接”。 这不是“标准”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.

我不认为这有什么特别的问题，这只是风格的问题。它在以下情况下很有用:

您需要一次设置多个字段(包括在构建时) 您知道在编写代码时需要设置哪些字段 对于想要设置的字段，有许多不同的组合。

这种方法的替代方法可能是:

一个mega构造函数(缺点:你可能会传递很多空值或默认值，并且很难知道哪个值对应什么) 几个重载的构造函数(缺点:一旦你有多个构造函数，就会变得笨拙) 工厂方法/静态方法(缺点:与重载构造函数相同——一旦超过几个就会变得笨拙)

如果你一次只设置几个属性，我会说不值得返回this。如果您稍后决定返回其他内容，例如状态/成功指示符/消息，那么它肯定会崩溃。

如果在整个应用程序中使用相同的约定，则似乎没有问题。

另一方面，如果应用程序的现有部分使用标准约定，我会坚持下去，并向更复杂的类添加构建器

public class NutritionalFacts {
    private final int sodium;
    private final int fat;
    private final int carbo;

    public int getSodium(){
        return sodium;
    }

    public int getfat(){
        return fat;
    }

    public int getCarbo(){
        return carbo;
    }

    public static class Builder {
        private int sodium;
        private int fat;
        private int carbo;

        public Builder sodium(int s) {
            this.sodium = s;
            return this;
        }

        public Builder fat(int f) {
            this.fat = f;
            return this;
        }

        public Builder carbo(int c) {
            this.carbo = c;
            return this;
        }

        public NutritionalFacts build() {
            return new NutritionalFacts(this);
        }
    }

    private NutritionalFacts(Builder b) {
        this.sodium = b.sodium;
        this.fat = b.fat;
        this.carbo = b.carbo;
    }
}

我同意所有声称这破坏了JavaBeans规范的帖子。有理由保留这一点，但我也觉得使用这个构建器模式(上面提到的)有它的一席之地;只要不是到处都用，就应该是可以接受的。对我来说，“It’s Place”的终点是对“build()”方法的调用。

There are other ways of setting all these things of course, but the advantage here is that it avoids 1) many-parameter public constructors and 2) partially-specified objects. Here, you have the builder collect what's needed and then call its "build()" at the end, which can then ensure that a partially-specified object is not constructed, since that operation can be given less-than-public visibility. The alternative would be "parameter objects", but that IMHO just pushes the problem back one level.

我不喜欢多形参构造函数，因为它们更有可能传入大量相同类型的实参，从而更容易将错误的实参传递给形参。我不喜欢使用大量的setter，因为对象可以在完全配置之前使用。此外，使用“build()”方法更好地实现基于先前选择的默认值的概念。

总之，我认为这是一个很好的实践，如果使用得当。

这一点也不坏。但是它与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();