Builder设计模式

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

使用场景

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

二、当构造过程必须容许被构造的对象有不一样的表示时，好比一台电脑便可以使用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);
    }
}

模式优缺点

优势：

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

二、将构造代码和表示代码分离，构造代码至关于builder，表示代码至关于director。不一样的导向器能够使用相同的生成器也构造不一样的产品。