设计模式之建造者模式（Builder）以及构建器

定义

• 复杂对象的构建与它的表示分离,
• 使得同样的构建过程可以创建不同的表示.
• 用户不知道内部的具体构建细节

为何使用

• 构建复杂对象的过程和部件解耦

使用

• 建立一个产品类
• 建立一个建造者接口，里面是组件各个部件的方法
• 实现具体的建造方案即面向接口编程
• 指挥者选择建造者，并建造产品

import java.util.ArrayList;
import java.util.Arrays;


/**
 * @author sun
 *  建造者模式
 */
public class BuilderModel {
    //运行函数入口
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建一种建造方式
        Builder b1=new concerteBuild1();
        //创建指挥者
        Director d=new Director();
        //建造
        d.construct(b1);
        //打印信息
        b1.printProduct();
    }

}
//指挥者
class Director{
    public void construct(Builder b){
    //创建A部件
        b.buildA();
        //创建B部件
        b.buildB();
    }

}

//产品
class Product{
//存放各个部件
    private ArrayList<String> products=new ArrayList<String>();
    public void add(String aspect){
        products.add(aspect);
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return Arrays.toString(products.toArray());
    }
}
//建造者接口
interface Builder{
    public void buildA();
    public void buildB();
    public void printProduct();
}
//建造方案1
class concerteBuild1 implements Builder{
    private Product product=new Product();
    public void buildA() {
        // TODO Auto-generated method stub
        product.add("A");
    }

    public void buildB() {
        // TODO Auto-generated method stub
        product.add("B");
    }
    public void printProduct() {
        // TODO Auto-generated method stub
        System.out.println(product);
    }
}
//建造方案2
class concerteBuild2 implements Builder{
    private Product product=new Product();
    public void buildA() {
        // TODO Auto-generated method stub
        product.add("X");
    }

    public void buildB() {
        // TODO Auto-generated method stub
        product.add("Y");
    }

    @Override
    public void printProduct() {
        // TODO Auto-generated method stub
        System.out.println(product);
    }
}

构建器builder

• 一个类参数很多 比如person有10个参数
• 在初始化person时传统的构造器需要传入10个参数
• 然而10个参数实际上的意义很难理解，不容易维护
• 使用构建器解决这种问题

public class TestBuilder {
//外面的对象是不可变的
    private final String name;
    private final int age;
    private final String adress;
    private final String call;
    public static void main(String args){
        TestBuilder build = new TestBuilder.builder("zhangsan", 10).adress("XXX").call("XXX").Build();
    }
    private TestBuilder(builder builder) {
        // TODO Auto-generated constructor stub
        name=builder.name;
        age=builder.age;
        adress=builder.adress;
        call=builder.call;
    }
    //一个静态的构建器
    public static class builder{
        private String name="null";
        private int age=-1;
        private String adress=null;
        private String call=null;
        public  builder(String name, int age) {
            this.name=name;
            this.age=age;
        }
        //返回自己的引用
        public builder adress(String adress){
            this.adress=adress;
            return this;
        }
        public builder call(String call){
            this.call=call;
            return this;
        }
        public TestBuilder Build(){
            return new TestBuilder(this);
        }
    }
}