设计模式之建造者模式

Builder模式是一步一步创建一个复杂对象的创建者模型，客户可以在不知道内部构造的情况下，精准地控制对象的操作流程，此模式就是为了将一个复杂的对象和它的部件解耦，使得构建过程和部件的表示隔离开来。

它有如下几个使用场景：

（1）相同的方法，不同的执行顺序，产生不同的时间结果时。
（2）多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同时
（3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用也比较合适。

下面我们对这种模式中的几个角色进行一下介绍：

1.Builder
为创建一个Product对象的各个部件指定抽象接口。

2.ConcreteBuilder
实现Builder的接口以构造和装配该产品的各个部件。
定义并明确它所创建的表示。
提供一个检索产品的接口。

3.Director
构造一个使用Builder接口的对象。

4.Product
表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。
包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

---

下面我们来简单地用java来实现一下：
我们先建一个计算机抽象类：

public abstract class Computer {

//计算机的抽象类，就是代表product生产者
public String board;
public String display;
public String os;




public Computer() {
    super();
}

//设置cpu核心数
public void setBoard(String board) {
    this.board = board;
}

//设置操作系统
public void setDisplay(String display) {
    this.display = display;
}

public abstract void setos();


@Override
public String toString() {
    return "Computer [board=" + board + ", display=" + display + ", os="
            + os + "]";
}

}

再来建一个计算机的实现类：

public class MYcomputer extends Computer {
@Override
public void setos() {
    os="大苹果";

}

public MYcomputer() {
    // TODO Auto-generated constructor stub
}

}

再来建一个Builder类：

public  abstract class Builder {
    //设置主机
    public abstract void buildBoard(String board);
    //设置显示器
    public abstract void buildDisplay(String display);
    //设置操作系统
    public abstract void buildos();
    //创建Computer
    public abstract  Computer create();
}

再来建一个Builder的实现类：

//具体的builder类
public class MYcomputerbuilder extends Builder {

     private Computer soncomputer=new MYcomputer();

    @Override
    public void buildBoard(String board) {
        soncomputer.setBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        soncomputer.setDisplay(display);
    }

    @Override
    public void buildos() {
        soncomputer.setos();        
    }

    @Override
    public Computer create() {
        // TODO Auto-generated method stub
        return soncomputer;
    }

}

再来建一个Dirertor类负责去构造Computer：

//Dirertor 负责构造Computer
public class Dirertor {

    Builder mybuilder = null;

    public Dirertor(Builder mybuilder) {
        super();
        this.mybuilder = mybuilder;
    }

    public void construct(String board,String display){
        mybuilder.buildBoard(board);
        mybuilder.buildDisplay(display);
        mybuilder.buildos();
    }
}

最后我们来进行测试：

public class Test {

    public static void main(String[] args) {
        //构造器
        Builder  sonbuild = new MYcomputerbuilder();
        Dirertor pcdirertor = new Dirertor(sonbuild);
        //封装构建过程
        pcdirertor.construct("高大上主板", "高大上显示器");
        //构建计算机输出相关信息
        System.out.println("computer:"+sonbuild.create().toString());
    }
}

输出结果是：

我们再来描述一下：上面我们通过MYcomputerbuilder来构建MYcomputer对象，Director则封装了构建这个对象的过程，对外隐藏了构建细节，Builder与Director共同将一个复杂对象的构建与表示分离，使得同样的构建过程可以构建不同的对象，好了先说这么多了，以后可以大家再深入讨论，，要去睡觉了。。。