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

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

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

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

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

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

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

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

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

如果你不想从setter返回'this'，但又不想使用第二个选项，你可以使用下面的语法来设置属性:

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

顺便说一句，我认为它在c#中略干净:

list.Add(new Employee() {
    Name = "Jack Sparrow",
    Id = 1,
    Foo = "bacon!"
});

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

这可能可读性较差

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

或者这个

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

这比:

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