假设您有一个名为Customer的类，其中包含以下字段:
假设根据您的业务逻辑，所有客户对象都必须定义这四个属性。
现在，我们可以通过强制构造函数指定每个属性来轻松地实现此目的。但是，当您被迫向Customer对象添加更多所需字段时，很容易看出这可能会失控。
我见过一些类将20多个参数传入其构造函数，使用起来非常麻烦。但是，如果您不需要这些字段，则存在未定义信息的风险，或者更糟糕的是，如果依赖调用代码指定这些属性，则可能出现对象引用错误。
是否有其他替代方案，还是您只能决定X数量的构造函数参数是否太多并接受它们呢？
需要考虑的两种设计方法
Essence模式
这两种方法在意图上相似，即我们逐步构建一个中间对象，然后在单个步骤中创建目标对象。
流畅接口模式的示例：
public class CustomerBuilder {
String surname;
String firstName;
String ssn;
public static CustomerBuilder customer() {
return new CustomerBuilder();
}
public CustomerBuilder withSurname(String surname) {
this.surname = surname;
return this;
}
public CustomerBuilder withFirstName(String firstName) {
this.firstName = firstName;
return this;
}
public CustomerBuilder withSsn(String ssn) {
this.ssn = ssn;
return this;
}
// client doesn't get to instantiate Customer directly
public Customer build() {
return new Customer(this);
}
}
public class Customer {
private final String firstName;
private final String surname;
private final String ssn;
Customer(CustomerBuilder builder) {
if (builder.firstName == null) throw new NullPointerException("firstName");
if (builder.surname == null) throw new NullPointerException("surname");
if (builder.ssn == null) throw new NullPointerException("ssn");
this.firstName = builder.firstName;
this.surname = builder.surname;
this.ssn = builder.ssn;
}
public String getFirstName() { return firstName; }
public String getSurname() { return surname; }
public String getSsn() { return ssn; }
}
import static com.acme.CustomerBuilder.customer;
public class Client {
public void doSomething() {
Customer customer = customer()
.withSurname("Smith")
.withFirstName("Fred")
.withSsn("123XS1")
.build();
}
}
CustomerBuilder和Customer中复制实例变量。此示例如果所有实例变量都是可选的，则可以接受，但如果所有实例变量都是必需的，并且有数十个，则我不确定您是否能够避免使用包含所有这些参数的构造函数。
如果没有带有所有必需属性的构造函数，那么作为客户端编码者，我将无法通过即将创建的类的接口看到该要求，这是我不喜欢的事情。 - dragan.stepanovic我看到有些人建议将七作为上限。显然，人们一次只能记住四个东西，而不是七个(Susan Weinschenk，《100 Things Every Designer Needs to Know about People》，48页)。即便如此，我认为四个也是一个很高的地球轨道。但这是因为我的思维已经被Bob Martin改变了。
在《Clean Code》中，Uncle Bob主张将参数数量限制在三个以内。他做出了激进的声明(40):
函数的理想参数数目是零（niladic）。其次是一个(monadic)，紧随其后的是两个(dyadic)。应尽量避免使用三个(triadic) 参数。超过三个(polyadic)需要非常特殊的理由，并且那种情况下也不应该使用。
他之所以这样说，是因为可读性；也因为可测试性：
想象一下编写所有测试用例以确保各种参数组合正常工作的困难。
我鼓励你找一本他的书，阅读他关于函数参数的完整讨论（40-43页）。
我同意那些提到单一责任原则的人。对我来说很难相信一个需要超过两个或三个值/对象且没有合理默认值的类只有一种责任，并且不会因为提取另一个类而变得更好。
现在，如果你通过构造函数注入依赖项，Bob Martin关于调用构造函数的简易性的论点并不完全适用（因为通常情况下你的应用程序中只有一个地方进行连接，或者你甚至拥有一个框架可以为你完成它）。然而，单一责任原则仍然相关：一旦一个类具有四个依赖项，我认为这是一种代码异味，说明它正在做大量的工作。
然而，与计算机科学中的所有事物一样，有大量构造函数参数的情况无疑是有效的。不要扭曲你的代码来避免使用大量的参数;但如果你确实使用了很多参数，请停下来仔细思考，因为这可能意味着你的代码已经很扭曲了。
对于您的情况，请坚持使用构造函数。信息应放在客户端，4个字段足矣。
如果您有许多必填和可选字段，则构造函数不是最佳解决方案。正如@boojiboy所说，它很难阅读，编写客户端代码也很困难。
@contagious建议使用默认模式和可选属性的设置器。这会使字段变得可变，但这只是一个小问题。
Effective Java 2中的Joshua Block表示，在这种情况下，您应该考虑使用构建器。以下是书中的一个示例：
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public static class Builder {
// required parameters
private final int servingSize;
private final int servings;
// optional parameters
private int calories = 0;
private int fat = 0;
private int carbohydrate = 0;
private int sodium = 0;
public Builder(int servingSize, int servings) {
this.servingSize = servingSize;
this.servings = servings;
}
public Builder calories(int val)
{ calories = val; return this; }
public Builder fat(int val)
{ fat = val; return this; }
public Builder carbohydrate(int val)
{ carbohydrate = val; return this; }
public Builder sodium(int val)
{ sodium = val; return this; }
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
soduim = builder.sodium;
carbohydrate = builder.carbohydrate;
}
}
然后像这样使用：
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
calories(100).sodium(35).carbohydrate(27).build();
以上示例摘自《Effective Java 2》
这不仅适用于构造方法。引用肯特·贝克（Kent Beck）在《实现模式》中的话：
setOuterBounds(x, y, width, height);
setInnerBounds(x + 2, y + 2, width - 4, height - 4);
将矩形明确为一个对象可以更好地解释代码：
setOuterBounds(bounds);
setInnerBounds(bounds.expand(-2));
我认为你的问题更多地涉及到类的设计而不是构造函数中参数的数量。如果我需要20个数据（参数）才能成功初始化一个对象，我可能会考虑将类进行拆分。
如果您有太多难以处理的参数，那么只需将它们打包到结构体/POD类中，最好声明为正在构建的类的内部类。这样一来，您仍然可以要求字段，同时使调用构造函数的代码相对容易阅读。
我认为这完全取决于具体情况。对于像您举的例子中的客户类，我不会冒险在需要时数据未定义。另一方面，传递结构体可以清理参数列表，但仍需在结构体中定义许多内容。
我会将类似的字段封装成一个具有自己构建/验证逻辑的对象。
例如，如果你有：
我会创建一个类来存储电话和地址，并使用标签指定它是“家庭”还是“商务”电话/地址。然后将这4个字段简化为一个数组。
ContactInfo cinfos = new ContactInfo[] {
new ContactInfo("home", "+123456789", "123 ABC Avenue"),
new ContactInfo("biz", "+987654321", "789 ZYX Avenue")
};
Customer c = new Customer("john", "doe", cinfos);
这样做看起来就不会像意大利面条一样混乱了。
如果你有很多字段，肯定有一些模式可以提取出来，使其成为一个良好的功能单元。这样还可以让代码更易读。
以下也是可能的解决方案：
CustomerFactory类来帮助构建Customer样式很重要，如果有一个带有20多个参数的构造函数，则应该修改设计。提供合理的默认值。