构建器模式（BuilderPattern）

1.构建器模式

定义

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

使用场景

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

解决的问题

当一个类的构造函数参数超过4个，而且这些参数有些是可选的时，我们通常有两种办法来构建它的对象。 例如我们现在有如下一个类计算机Computer，其中cpu与ram是必填参数，而其他4个是可选参数。

public class Computer 
{
    private String cpu;			// 必须
    private String ram;			// 必须
    private int usbCount;		// 可选
    private String keyboard;	// 可选
    private String display;		// 可选
    private String mouse;		// 可选
}

通过一般构造函数实现：

public class Computer 
{
    public Computer(String cpu, String ram) 
    {
        this(cpu, ram, 0);
    }
    
    public Computer(String cpu, String ram, int usbCount) 
    {
        this(cpu, ram, usbCount, "罗技键盘");
    }
    
    public Computer(String cpu, String ram, int usbCount, String keyboard) 
    {
        this(cpu, ram, usbCount, keyboard, "三星显示器");
    }
    
    public Computer(String cpu, String ram, int usbCount, String keyboard, String display) 
    {
        this.cpu = cpu;
        this.ram = ram;
        this.usbCount = usbCount;
        this.keyboard = keyboard;
        this.display = display;
    }
}

弊端: 阅读不方便。你可以想象一下，当你要调用一个类的构造函数时，你首先要决定使用哪一个，然后里面又是一堆参数，如果这些参数的类型很多又都一样，你还要搞清楚这些参数的含义，很容易就传混了。

解决方案

生成器模式建议将对象构造代码从产品类中抽取出来， 并将其放在一个名为生成器的独立对象中。

2. UML类图

• Product: 最终要生成的对象，例如 Computer实例。
• Builder： 构建者的抽象基类（有时会使用接口代替）。其定义了构建Product的抽象步骤，其实体类需要实现这些步骤。其会包含一个用来返回最终产品的方法Product getProduct()。
• ConcreteBuilder: Builder的实现类。
• Director: 决定如何构建最终产品的算法. 其会包含一个负责组装的方法void Construct(Builder builder)， 在这个方法中通过调用builder的方法，就可以设置builder，等设置完成后，就可以通过builder的 getProduct() 方法获得最终的产品。

4.具体实现

Computer类:

public class Computer
{
    private string cpu; // 必须
    private string ram; // 必须
    private int? usbCount;    // 可选
    private string? mouse;       // 可选
    private string? keyboard;    // 可选
    private string? display;     // 可选

    public Computer(string cpu, string ram)
    {
        this.cpu = cpu;
        this.ram = ram;
    }

    public void SetUsbCount(int usbCount)
    {
        this.usbCount = usbCount;
    }

    public void SetKeyboard(string keyboard)
    {
        this.keyboard = keyboard;
    }

    public void SetMouse(string mouse)
    {
        this.mouse = mouse;
    }

    public void SetDisplay(string display)
    {
        this.display = display;
    }

    // 重写ToSting打印电脑信息
    public override string ToString()
    {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", usbCount=" + usbCount +
                ", mouse=" + mouse +
                ", keyboard='" + keyboard + '\'' +
                ", display='" + display + '\'' +
                '}';
    }
}

4.1 传统构建器模式

抽象构建类：

// 抽象构建者类，负责构建电脑可选参数
public abstract class ComputerBuild
{
    // 设置电脑Usb数量
    public abstract void SetUsbCount();
    // 设置鼠标
    public abstract void SetMouse();
    // 设置键盘
    public abstract void SetKeyboard();
    // 设置显示器
    public abstract void SetDisplay();

    // 获取电脑产品实例
    public abstract Computer GetComputer();
}

具体电脑构建类：

// 苹果电脑构建者类
public class MacComputerBuilder : ComputerBuild
{
    Computer computer;

    public MacComputerBuilder(string cpu, string ram)
    {
        computer = new Computer(cpu, ram);
    }

    public override void SetDisplay()
    {
        computer.SetDisplay("苹果显示器");
    }

    public override void SetKeyboard()
    {
        computer.SetKeyboard("苹果键盘");
    }

    public override void SetMouse()
    {
        computer.SetMouse("苹果鼠标");
    }

    public override void SetUsbCount()
    {
        computer.SetUsbCount(2);
    }

    public override Computer GetComputer()
    {
        return computer;
    }
}

// 戴尔电脑构建器
public class DellComputerBuilder : ComputerBuild
{
    Computer computer;

    public DellComputerBuilder(string cpu, string ram)
    {
        computer = new Computer(cpu, ram);
    }

    public override void SetDisplay()
    {
        computer.SetDisplay("戴尔显示器");
    }

    public override void SetKeyboard()
    {
        computer.SetKeyboard("戴尔键盘");
    }

    public override void SetMouse()
    {
        computer.SetMouse("戴尔鼠标");
    }

    public override void SetUsbCount()
    {
        computer.SetUsbCount(4);
    }

    public override Computer GetComputer()
    {
        return computer;
    }
}

**导演类：**负责组装电脑零件

public class ComputerDirector
{
    // 组装电脑,返回组装好的电脑
    public Computer MakeComputer(ComputerBuild computerBuild)
    {
        computerBuild.SetDisplay();
        computerBuild.SetKeyboard();
        computerBuild.SetMouse();
        computerBuild.SetUsbCount();

        return computerBuild.GetComputer();
    }
}

使用：

ComputerDirector director = new ComputerDirector();
// 构建苹果电脑
ComputerBuild macBuilder = new MacComputerBuilder("I5处理器", "三星125");
Computer macComputer = director.MakeComputer(macBuilder);
Console.WriteLine(macComputer.ToString());

// 构建dell电脑
ComputerBuild dellBuilder = new DellComputerBuilder("I7处理器", "海力士222");
Computer dellComputer = director.MakeComputer(dellBuilder);
Console.WriteLine(dellComputer.ToString());

/*
Computer{cpu='I5处理器', ram='三星125', usbCount=2, mouse=苹果鼠标, keyboard='苹果键盘', display='苹果显示器'}
Computer{cpu='I7处理器', ram='海力士222', usbCount=4, mouse=戴尔鼠标, keyboard='戴尔键盘', display='戴尔显示器'}
*/

4.2 链式编程模式

电脑构建器类：

public class ComputerBuliderChain
{
    private Computer computer;

    public ComputerBuliderChain(string cpu, string arm)
    {
        computer = new Computer(cpu, arm);
    }

    public ComputerBuliderChain SetUsbCount(int count)
    {
        computer.SetUsbCount(count);
        return this;
    }

    public ComputerBuliderChain SetMouse(string mouse)
    {
        computer.SetMouse(mouse);
        return this;
    }

    public ComputerBuliderChain SetDisplay(string display)
    {
        computer.SetDisplay(display);
        return this;
    }

    public ComputerBuliderChain SetKeyboard(string keyboard)
    {
        computer.SetKeyboard(keyboard);
        return this;
    }

	// 生产电脑
    public Computer Build()
    {
        return computer;
    }
}

调用：

Computer computer = 
        new ComputerBuliderChain("因特尔", "三星")
        .SetDisplay("三星24寸")
        .SetKeyboard("罗技")
        .SetMouse("雷蛇")
        .SetUsbCount(3)
        .Build();

        Console.WriteLine(computer.ToString());

结果：

// Computer{cpu='因特尔', ram='三星125', usbCount=3, mouse=雷蛇, keyboard='罗技', display='三星24寸'}