设计模式之建造者模式

设计模式是一套被反复使用，多数人知晓，经过分类编目的，代码设计的总结，也可以说是前人的智慧结晶。学习设计模式能让我们对一些应用场景使用相同的套路达到很好的效果，我会不定时更新一些自己对设计模式的理解的文章，从定义，实现，应用场景来说说设计模式，今天我要说的对象是建造者模式
        一：定义
        建造者模式(Builder Pattern)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。
        二：实现
        一个标准的构建者模式通常油4部分组成
        1.抽象的产品类product：
        定义产品的公共属性，以及getter,setter方法
        2.抽象的建造类builder：
        抽象每个属性的创建方法以及一个组装方法，这个方法把零散的属性组装成完成的对象
        3.具体的建造类ProductBuilder：
        所有的具体建造类都继承抽象的建造类，不同的产品对具体属于有不通实现
        4.指挥者类director：
        控制实际构建过程的类，只需要将一个具体的建造类的实例指向抽象的建造类的引用，           然后调用抽象引用的组装方法，就可以得到具体的产品
//产品类
class Products{
    public String partA;//A属性，实际开发中可能是复杂的对象实例
    public String partB;//B属性，实际开发中可能是复杂的对象实例
    public String partC;//C属性，实际开发中可能是复杂的对象实例

    //重写toString方法，方便演示
    @Override
    public String toString() {
        return "Products{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }
}

//抽象的建造类
abstract class Build{
    public Products products;//给子类引用

    public abstract void buildPartA();//对A属性的构建方法

    public abstract void buildPartB();//对B属性的构建方法

    public abstract void buildPartC();//对C属性的构建方法

    public abstract Products createProducts();//抽象的组装成完整对象的方法
}

//具体的建造类，这种类型的类可以有多个，用户建造不同的实例
class ProductBuild  extends Build{

    @Override
    public void buildPartA() {
        products.setPartA("这是partA");//给父类的属性A设置
    }

    @Override
    public void buildPartB() {
        products.setPartB("这是partB");//给父类的属性B设置
    }

    @Override
    public void buildPartC() {
        products.setPartC("这是partC");//给父类的属性C设置
    }

    //编写具体的建造方法，返回组装完成后的对象
    @Override
    public Products createProducts() {
        products=new Products();//实例化具体的产品类
        buildPartA();
        buildPartB();
        buildPartC();
        return products;
    }
}


//指挥者类
class Director{
    //建造类，使用具体的建造类，创建复杂对象
    public static void construct(){
        Build build=new ProductBuild();
        Products product=build.createProducts();
        System.out.println(product);
    }
    //测试
    public static void main(String[] dfdf){
        Director.construct();
    }
}
从代码可以看得出来，建造者模式一般用于构建一个复杂的对象，同样的构建过程可以构建不通的表示，也就是不通的实例。很自然的让我们想到抽象工厂模式，同一个工厂也可以创建不通的实例，不过建造者模式和工厂模式又有所不通，因为它构建的对象是复杂的。假如一个建造者模式构建出来的对象有A,B,C,D,E五个部分组成，那么这五个部分都需要一个专门的build方法来创建它。不过不同于抽象工厂类的事，建造者模式创建的是一个复杂对象，而抽象工厂模式创建出来的事有相互联系的多个对象。相同的是，建造者模式的具体建造者类可以有多个，用户建造不同的产品

        三：应用场景
        在以下情况下可以考虑使用建造者模式：
        (1) 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
        (2) 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
        (3) 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过
        程封装在指挥者类中，而不在建造者类和客户类中。
        (4) 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。