JAVA Builder建造者模式

建造者模式

1. 建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，用于解决”复杂对象的创建”工作。
2. 使用多个简单的方法一步步构建出复杂的对象，提供了一种创建复杂对象的最佳方式，一般可采用链式编程实现建造者模式。

构建过程

1. 从被创建类中抽象出AbstractBuilder基类（抽象类或接口）。
2. 创建建造类ConcreteBuilder实现AbstractBuilder基类的抽象方法。
3. 使用建造类ConcreteBuilder建造复杂对象，建造过程中尽量采用链式编程。

使用场景

1. 复杂对象的构建。

DEMO

一个采用内部类和链式编程实现的构建电脑的过程。

建造者抽象接口：

//建造接口
public interface Builder {
    Builder setCpu(String cpu);
    Builder setRam(String ram);
    Builder setDisplay(String display);
    Builder setKeyboard(String keyboard);
    Builder setMouse(String mouse);
    Computer GetComputer();
}

含有内部建造类ComputerBuilder的Computer类，Computer类持有ComputerBuilder类静态对象，外部通过Builder()方法访问ComputerBuilder，构建Computer。

//建造者DEMO
public class Computer
{
    private static Computer BuilderMother = new Computer();
    private String cpu = "default";
    private String ram = "default";
    private String display = "default";
    private String keyboard = "default";
    private String mouse = "default";
    //外部不可实例化，只能通过Builder接口建造
    private Computer(){}

    //建造接口
    //使用BuilderMother初始化一个静态ComputerBuilder
    public static Builder Builder()
    {
        return BuilderMother.new ComputerBuilder();
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", display='" + display + '\'' +
                ", keyboard='" + keyboard + '\'' +
                ", mouse='" + mouse + '\'' +
                '}';
    }

    //建造者放在内部类中比较合适
    private class ComputerBuilder implements Builder
    {
        private Computer computer = new Computer();

        @Override
        public Builder setCpu(String cpu) {
            computer.cpu = cpu;
            return this;
        }

        @Override
        public Builder setRam(String ram) {
            computer.ram = ram;
            return this;
        }

        @Override
        public Builder setDisplay(String display) {
            computer.display = display;
            return this;
        }

        @Override
        public Builder setKeyboard(String keyboard) {
            computer.keyboard = keyboard;
            return this;
        }

        @Override
        public Builder setMouse(String mouse) {
            computer.mouse = mouse;
            return this;
        }

        @Override
        public Computer GetComputer() {
            return computer;
        }
    }
}

主方法类

public class Builder_v1 {

    public static void main(String[] args) {
        Computer myComputer = Computer.Builder().setCpu("AMD")
                .setDisplay("AOC")
                .setRam("16G")
                .setMouse("Logitech")
                .setKeyboard("ICBK")
                .GetComputer();

        Computer myComputer1 = Computer.Builder().setDisplay("DELL")
           								.GetComputer();

        System.out.println(myComputer);
        System.out.println(myComputer1);

    }
}

缺点

1. 若产品内部发生变化，建造者都要修改，成本较大；若内部变化复杂，会有很多的建造类