构建大的、不可变的对象，而不使用具有长参数列表的构造函数

Question

我有一些大的（超过 3 个字段）对象，它们可以而且应该是不可变的。每次遇到这种情况，我都会创建带有长参数列表的令人厌恶的构造函数。

感觉不太对劲，很难使用，而且可读性也受到影响。

如果字段是某种集合类型（例如列表），情况会更糟。一个简单的 addSibling(S s) 可以大大简化对象的创建，但会使对象变得可变。

你们在这种情况下用什么？

我使用 Scala 和 Java，但我认为只要语言是面向对象的，问题就与语言无关。

我能想到的解决方案：

1. “带有长参数列表的构造函数令人厌恶”
2. 构建器模式

Answer 1

那么，您想要一个更易于阅读且创建后不可变的对象吗？

我认为流畅的界面正确完成会对您有所帮助。

它看起来像这样（纯粹是编造的例子）：

final Foo immutable = FooFactory.create()
    .whereRangeConstraintsAre(100,300)
    .withColor(Color.BLUE)
    .withArea(234)
    .withInterspacing(12)
    .build();

我用粗体写了“正确完成”，因为大多数 Java 程序员都会错误地使用流畅的接口，并使用构建对象所需的方法污染他们的对象，这是当然完全错误。

诀窍是只有 build() 方法实际上创建了 Foo（因此 Foo 可以是不可变的）。

FooFactory.create()、whereXXX(..) 和 withXXX(..) 都创建“其他东西”。

其他的东西可能是 FooFactory，这是一种方法......

你的 FooFactory 看起来像这样：

// Notice the private FooFactory constructor
private FooFactory() {
}

public static FooFactory create() {
    return new FooFactory();
}

public FooFactory withColor( final Color col ) {
    this.color = color;
    return this;
}

public Foo build() {
    return new FooImpl( color, and, all, the, other, parameters, go, here );
}

Answer 2

在 Scala 2.8 中，您可以在案例类上使用命名参数和默认参数以及 copy 方法。这是一些示例代码：

case class Person(name: String, age: Int, children: List[Person] = List()) {
  def addChild(p: Person) = copy(children = p :: this.children)
}

val parent = Person(name = "Bob", age = 55)
  .addChild(Person("Lisa", 23))
  .addChild(Person("Peter", 16))

Answer 3

好吧，考虑一下 Scala 2.8：

case class Person(name: String, 
                  married: Boolean = false, 
                  espouse: Option[String] = None, 
                  children: Set[String] = Set.empty) {
  def marriedTo(whom: String) = this.copy(married = true, espouse = Some(whom))
  def addChild(whom: String) = this.copy(children = children + whom)
}

scala> Person("Joseph").marriedTo("Mary").addChild("Jesus")
res1: Person = Person(Joseph,true,Some(Mary),Set(Jesus))

当然，这确实存在一些问题。例如，尝试创建espouse 和Option[Person]，然后让两个人结婚。我想不出一种方法来解决这个问题，而不求助于 private var 和/或 private 构造函数加上工厂。

Answer 4

这里还有几个选项：

选项 1

使实现本身可变，但将其公开的接口分为可变接口和不可变接口。这是取自 Swing 库的设计。

public interface Foo {
  X getX();
  Y getY();
}

public interface MutableFoo extends Foo {
  void setX(X x);
  void setY(Y y);
}

public class FooImpl implements MutableFoo {...}

public SomeClassThatUsesFoo {
  public Foo makeFoo(...) {
    MutableFoo ret = new MutableFoo...
    ret.setX(...);
    ret.setY(...);
    return ret; // As Foo, not MutableFoo
  }
}

选项 2

如果您的应用程序包含大量预定义的不可变对象（例如配置对象），您可以考虑使用 Spring 框架。

Answer 5

它有助于记住有 不同种类的不变性。对于你的情况，我认为“冰棒”不变性会非常有效：

冰棒不变性：就是我
异想天开地称之为轻微削弱
一次写入的不变性。一个可以
想象一个物体或一个场
暂时保持不稳定
在其初始化期间，然后
被永远“冻结”了。这种
不变性特别有用
对于循环的不可变对象
互相引用，或者不可变
已序列化的对象
磁盘并在反序列化时需要
保持“流动”，直到整个
反序列化过程完成，在
所有物体可能在哪个点
冻结。

因此，您初始化对象，然后设置某种“冻结”标志，表明它不再可写。最好将突变隐藏在函数后面，这样该函数对于使用 API 的客户端来说仍然是纯粹的。

Answer 6

您还可以使不可变对象公开看起来像变异器（如 addSibling）的方法，但让它们返回一个新实例。这就是不可变的 Scala 集合的作用。

缺点是您可能会创建不必要的实例。它也仅适用于存在中间有效配置的情况（例如某些没有兄弟节点的节点，这在大多数情况下都可以），除非您不想处理部分构建的对象。

例如，还没有目的地的图边不是有效的图边。

Answer 7

考虑四种可能性：

new Immutable(one, fish, two, fish, red, fish, blue, fish); /*1 */

params = new ImmutableParameters(); /*2 */
params.setType("fowl");
new Immutable(params);

factory = new ImmutableFactory(); /*3 */
factory.setType("fish");
factory.getInstance();

Immutable boringImmutable = new Immutable(); /* 4 */
Immutable lessBoring = boringImmutable.setType("vegetable");

对我来说，2、3 和 4 中的每一种都适用于不同的情况。由于OP引用的原因，第一个很难让人喜欢，并且通常是设计遭受一些蠕变并需要一些重构的症状。

当“工厂”背后没有状态时，我列出的（2）是好的，而（3）是有状态时选择的设计。当我不想担心线程和同步时，我发现自己使用（2）而不是（3），并且我不需要担心在许多对象的生产中摊销一些昂贵的设置。另一方面，当实际工作进入工厂构建（从 SPI 设置、读取配置文件等）时，就会调用 (3)。

最后，其他人的答案提到了选项（4），其中有很多不可变的小对象，更好的模式是从旧对象中获取新对象。

请注意，我不是“模式粉丝俱乐部”的成员——当然，有些东西值得效仿，但在我看来，一旦人们给它们起了名字和有趣的帽子，它们就会过上无益的生活。

Answer 8

另一个潜在的选择是重构以减少可配置字段。如果字段组（大部分）只能相互协作，请将它们收集到自己的小型不可变对象中。该“小”对象的构造函数/构建器应该更易于管理，该“大”对象的构造函数/构建器也应该更易于管理。

Answer 9

我使用 C#，这些是我的方法。考虑：

class Foo
{
    // private fields only to be written inside a constructor
    private readonly int i;
    private readonly string s;
    private readonly Bar b;

    // public getter properties
    public int I { get { return i; } }
    // etc.
}

选项 1. 具有可选参数的构造函数

public Foo(int i = 0, string s = "bla", Bar b = null)
{
    this.i = i;
    this.s = s;
    this.b = b;
}

用作例如 new Foo(5, b: new Bar(whatever))。不适用于 4.0 之前的 Java 或 C# 版本。但仍然值得展示，因为它是一个例子，说明并非所有解决方案都是与语言无关的。

选项 2. 构造函数采用单个参数对象

public Foo(FooParameters parameters)
{
    this.i = parameters.I;
    // etc.
}

class FooParameters
{
    // public properties with automatically generated private backing fields
    public int I { get; set; }
    public string S { get; set; }
    public Bar B { get; set; }

    // All properties are public, so we don't need a full constructor.
    // For convenience, you could include some commonly used initialization
    // patterns as additional constructors.
    public FooParameters() { }
}

使用示例：

FooParameters fp = new FooParameters();
fp.I = 5;
fp.S = "bla";
fp.B = new Bar();
Foo f = new Foo(fp);`

从 3.0 开始，C# 使用对象初始值设定项语法使其更加优雅（语义上与前面的示例相同）：

FooParameters fp = new FooParameters { I = 5, S = "bla", B = new Bar() };
Foo f = new Foo(fp);

选项 3：
重新设计您的类，使其不需要如此大量的参数。您可以将其职责分为多个类。或者根据需要，不将参数传递给构造函数，而仅传递给特定方法。并不总是可行，但当可行时，就值得去做。