设计模式-构建器模式

构建器模式（Builder）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

当一个类有大量的可选参数。例如:用一个类表示手机的各项指标，这些标签中有几个是必需的，而其他的是可选的。那我们如何表示这样的一个类呢？我们习惯的做法是:提供第一个只有必要参数的构造器。第二个构造器有一个可选参数，第三个有两个可选参数，依此类推，最后一个构造器包含所有可选参数。例如（为了简单起见，只显示了三个可选域）：

public class Phone{
    private final String brand;//品牌      required
    private final String model;//型号      required
    private final int battery;//电池电量    optional
    private final float screen;//屏幕尺寸   optional
    private final int pixels;// 像素       optional

    public Phone(String brand, String model){
        this(brand,model,0);
    }

    public Phone(String brand, String model, int battery){
        this(brand,model,battery,0);
    }

    public Phone(String brand, String model, int battery, float screen){
        this(brand,model,battery,screen,0);
    }

    public Phone(String brand, String model, int battery, float screen, int pixels)
    {
        this.brand = brand;
        this.model = model;
        this.battery = battery;
        this.screen = screen;
        this.pixels = pixels;
    }
}

此时，客户端的代码是这样的：

    Phone phone1 = new Phone("Samsung","Note 7");
    Phone phone2 = new Phone("Apple","iphone6s",500,0,1000);

这个构造器调用通常需要许多你本来不想设置的参数，但还是不得不为它们传递值。在上面的例子中，我们给screen传递了一个值为0。当然，如果只有这几个参数，看起来还好，但是随着参数数目的增加，问题很快就脱离了控制。
总而言之：当参有许多参数的时候，客户端代码会很难编写，并且难以阅读。如果代码的阅读者想知道那些只是什么意思，必须很仔细地数着这些参数来探个究竟。一长串类型相同的参数会 导致一些微妙的错误。如果客户端不小心颠倒了两个参数的顺序，编译时不会报错，但是程序运行时会出现错误的行为。

第二种方法是JavaBeans模式，在这种模式下，调用一个无参构造器来创建对象，然后调用setter方法来设置每个参数。例如：

public class Phone{
    private String brand   ="";//品牌       required
    private String model;  =""//型号        required
    private int battery    = 0;//电池电量    optional
    private float screen   = 0;//屏幕尺寸    optional
    private int pixels     = 0;//像素       optional

    public Phone(){}

    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setModel(String model) {
        this.model = model;
    }
    public void setBattery(int battery) {
        this.battery = battery;
    }
    public void setScreen(float screen) {
        this.screen = screen;
    }
    public void setPixels(int pixels) {
        this.pixels = pixels;
    }
}

这种模式创建实例很容易，代码读起来也很容易。

    Phone phone = new Phone();
    phone.setBrand("Apple");
    phone.setModel("iphone6s");
    phone.setBattery(500);
    phone.setScreen(17.6);
    phone.setPixels(1000);

JavaBeans模式阻止了把类做成不可变的可能。

还有第三种方法。

public class Phone {
    private final String brand;// 品牌
    private final String model;// 型号
    private final int battery;// 电池电量
    private final double screen;// 屏幕尺寸
    private final int pixels;// 像素

    public static class Builder {
        // Required parameters
        private final String brand;// 品牌
        private final String model;// 型号

        // Optional parameters
        private int battery = 0;// 电池电量
        private double screen = 0;// 屏幕尺寸
        private int pixels = 0;// 像素

        public Builder(String brand, String model) {
            this.brand = brand;
            this.model = model;
        }

        public Builder battery(int val) {
            battery = val;
            return this;
        }

        public Builder screen(double val) {
            screen = val;
            return this;
        }

        public Builder pixels(int val) {
            pixels = val;
            return this;
        }

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

    private Phone(Builder builder) {
        brand = builder.brand;
        model = builder.model;
        battery = builder.battery;
        screen = builder.screen;
        pixels = builder.pixels;
    }
}