Builder设计模式

Builder模式，又称生成器或构建者模式，属于对象创建型模式，侧重于一步一步的构建复杂对象，只有在构建完成后才会返回生成的对象。Builder模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

使用场景

1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时，比如买一台电脑，我不需要知道电脑CPU，主板，机箱是如何生产的，也不需要知道它们是如何组装的。

2、当构造过程必须允许被构造的对象有不同的表示时，比如一台电脑即可以使用AMD的CPU，也可以使用Inter的CPU，这些都是可以根据需求变化的。

/**
 * 构建者模式：将一个复杂对象的构建与它的表示分离， 使得同样的构建过程可以创建不同的表示。
 * 
 * @author qbg
 * 
 */
public class BuilderPattern {
    /**
     * 机箱抽象类
     */
    abstract class Crate {
        public String toString() {
            return "abstract crate...";
        }
    }

    /**
     * 酷冷至尊机箱
     */
    class CoolerMasterCrate extends Crate {
        public String toString() {
            return "CoolerMaster crate...";
        }
    }

    /**
     * CPU抽象类
     */
    abstract class CPU {
        public String toString() {
            return "abstract cpu...";
        }
    }

    /**
     * AMD CPU
     */
    class AMDCPU extends CPU {
        public String toString() {
            return "AMD cpu...";
        }
    }

    /**
     * 主板抽象类
     */
    abstract class Motherboard {
        public String toString() {
            return "abstract motherboard...";
        }
    }

    /**
     * 华硕主板
     */
    class ASUSMotherboard extends Motherboard {
        public String toString() {
            return "ASUS motherboard...";
        }
    }

    /**
     * 电脑定义类
     */
    class Computer {
        CPU cpu; // cpu
        Motherboard motherboard; // 主板
        Crate crate;// 机箱

        public String toString() {
            return "CPU:" + cpu + "\nMotherboard:" + motherboard + "\nCrate:"
                    + crate;
        }
    }

    /**
     * 电脑构建者接口，可以将CPU等部件通过工厂模式来生产，以进一步分离产品部件生成和构建的过程...
     */
    interface ComputerBuilder {
        public ComputerBuilder buildCPU();

        public ComputerBuilder buildMotherboard();

        public ComputerBuilder buildCrate();

        public Computer getProduct();
    }

    /**
     * 最热台式电脑构建实现类
     */
    class HotDeskComputerBuilder implements ComputerBuilder {
        private Computer computer;

        public HotDeskComputerBuilder() {
            this.computer = new Computer();
        }

        public ComputerBuilder buildCPU() {
            computer.cpu = new AMDCPU();
            return this;
        }

        public ComputerBuilder buildMotherboard() {
            computer.motherboard = new ASUSMotherboard();
            return this;
        }

        public ComputerBuilder buildCrate() {
            computer.crate = new CoolerMasterCrate();
            return this;
        }

        public Computer getProduct() {
            buildMotherboard().buildCPU().buildCrate();
            return computer;
        }
    }

    /**
     * 导向器,客户端通过导向器获取产品， 而不关心导向器是怎样获取到Builder生成器 构建的产品对象的。而具体的构建过程则交给具体的Builder。
     */
    class Director {
        private ComputerBuilder builder;

        public Director(ComputerBuilder builder) {
            this.builder = builder;
        }

        /**
         * 返回构造好的产品
         */
        public Computer construct() {
            return builder.getProduct();
        }
    }

    public static void main(String[] args) {
        BuilderPattern bp = new BuilderPattern();
        ComputerBuilder builder = bp.new HotDeskComputerBuilder();
        Director director = bp.new Director(builder);
        Computer computer = director.construct();
        System.out.println(computer);
    }
}

模式优缺点

优点：

1、可以改变一个产品的内部表示，比如示例中只要实现一个新的ComputerBuilder就能改变电脑的内部组件，因为电脑的表示和内部结构是独立于客户端代码的。

2、将构造代码和表示代码分离，构造代码相当于builder，表示代码相当于director。不同的导向器可以使用相同的生成器也构造不同的产品。