第二条：遇到多个构造器参数时要考虑用构建器

静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。

问题：当存在一个类有几个属性是必需的，还有一些属性是可选的，对于这样的类，我们可以用什么方法去编写呢？

第一种：重叠构造器模式。
在这种模式下，提供的第一个只有必要的参数的构造器，第二个构造器有一个可选参数，第三个构造器有两个可选参数，依次类推，最后一个构造器包含所有可选的参数。
示例：

/**
 * @description: 重叠构造器模式
 * @author: lty
 * @create: 2021-05-07 16:32
 **/
public class PersonCd {

    private String name;    // 必填属性
    private int age;        //必填属性
    private String sex;     //选填属性
    private String country; //选填属性

    public PersonCd(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public PersonCd(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public PersonCd(String name, int age, String sex, String country) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.country = country;
    }
}

当你想创建实例的时候，就利用参数列表最短的构造器，但是你想给country赋值时就需要最长的构造器还需要给sex赋值，但是这只是有四个参数，当参数越来越多，你就可能需要给许多你并不想设置的参数传递值。

总结：
重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难编写，并且仍能较难以阅读。如果读者想知道那些值是什么意思，必须很仔细地数着这些参数来探个究竟。一长串类型相同的参数会导致一些微妙的错误。如果客户端不小心颠倒了其中两个参数的顺序，编译器也不会报错，但是程序在运行时会出现错误的行为。

第二种：JavaBeans模式。
在这种模式下，调用一个无参构造器来创建对象，然后调用setter方法来设置每个必要的参数以及每个可选参数。
示例：

/**
 * @description: JavaBeans模式
 * @author: lty
 * @create: 2021-05-07 17:32
 **/
public class PersonJb {

    private String name;    // 必填属性
    private int age;        //必填属性
    private String sex;     //选填属性
    private String country; //选填属性

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setCountry(String country) {
        this.country = country;
    }
}

调用方式：

PersonJb personJb = new PersonJb();
personJb.setName("ll");
personJb.setAge(20);
personJb.setSex("女");
personJb.setCountry("中国");

总结：
这种模式弥补了重叠构造器模式的不足。创建实例很容易，代码读起来也很容易。但是JavaBeans模式自身有着很严重的缺点。就是它的构造过程分部到几次调用中，在构造过程中JavaBean可能处于不一致的状态，线程不安全。它有可能在构造的过程中被改变，这一点在多线程、高并发的程序中显得尤为重要。
类无法仅仅通过检验构造器参数的有效性来保持一致性。试图使用处于不一致状态的对象将会导致失败，这种失败与包含错误的代码大相径庭，因此调试起来十分困难。
与此相关的另一点不足在于，JavaBeans模式阻止了把类做成不可变的可能，这就需要程序员付出额外的努力来确保它的线程安全。
不仅如此，JavaBeans模式还有个缺点，如果对象中含有final修饰的字段，那么JavaBeans模式将不能对其执行setter操作。

第三种：Builder模式（构建器）。
既能保证像重叠构造器模式那样的安全性，也能保证像JavaBeans模式那么好的可读性。
它不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器，得到一个 builder 对象。然后客户端在 builder 对象上调用类似于 setter 的方法，来设置每个相关的可选参数。最后，客户端调用无参的 build 方法来生成通常是不可变的对象。这个 builder 通常是它构建的类的静态成员类。
示例：

/**
 * @description: Builder模式（构建器）
 * @author: lty
 * @create: 2021-05-07 19:32
 **/
public class PersonBuilder {

    private String name;    // 必填属性
    private int age;        //必填属性
    private String sex;     //选填属性
    private String country; //选填属性

        public static class Builder{
            private String name;
            private int age;
            private String sex;
            private String country;

            public Builder(String name, int age){
                this.name = name;
                this.age = age;
            }

            public Builder setSex(String sex){
                this.sex = sex;
                return this;
            }

            public Builder setCountry(String country){
                this.country = country;
                return this;
            }

            public PersonBuilder build(){
                return new PersonBuilder(this);
            }
        }
   public PersonBuilder(Builder builder){ //这个是不变的，所有默认参数值都单独放在一个地方
        this.name = builder.name;
        this.age = builder.age;
        this.sex = builder.sex;
        this.country = builder.country;
    }
}

调用方式：

PersonBuilder personBuilder = new PersonBuilder.Builder("ll",22).setSex("女").setCountry("中国").build();

总结：
这样客户端代码更容易编写，而且易于阅读。Builder 模式模拟了具名的可选参数。与构造器相比，builder 的略微优势在于，它可以有多个可变参数，因为 builder 利用单独的方法来设置每个参数。
  Builder 模式也有它自身的不足。为了创建对象，必须先创建它的构建器。虽然创建这个构建器的开销在实践中可能不那么明显，但是在某些十分注重性能的情况下，可能就成问题了。Builder 模式还比重叠构造器模式更加冗长，因此它只有在很多参数的时候才使用，比如4个或更多参数。如果已知将来就可能需要添加更多的参数，通常一开始就使用构建器。
  
最后：
  简而言之，如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builder 模式就是一种不错的选择，特别是当大多数参数都是可选或者类型相同的时候。与使用重叠构造器模式相比，使用 Builder 模式的客户端代码将更易于阅读和编写，构建器也比 Java Beans 更加安全。