java设计模式--建造者模式

首先咱们先看一个例子，假设咱们要生产CarA，CarB

public class CarA {

    public void makeWheels(){
        System.out.println("制造CarA的轮子");
    }

    public void makeCarBody(){
        System.out.println("制造车CarA车身");
    }

    public void sprayPaint(){
        System.out.println("给CarA喷漆");
    }

    public void build(){
        makeWheels();
        makeCarBody();
        sprayPaint();
    }
}

public class CarB {
    public void makeWheels(){
        System.out.println("制造CarB的轮子");
    }

    public void makeCarBody(){
        System.out.println("制造车CarB车身");
    }

    public void sprayPaint(){
        System.out.println("给CarB喷漆");
    }

    public void build(){
        makeWheels();
        makeCarBody();
        sprayPaint();
    }
}

public class Test {
    public static void main(String[] args) {
        CarA carA = new CarA();
        carA.build();

        CarB carB = new CarB();
        carB.build();
    }
}

结果：

制造CarA的轮子
制造车CarA车身
给CarA喷漆
制造CarB的轮子
制造车CarB车身
给CarB喷漆

　　从上面的例子咱们能够看到CarA和CarB有相同的构造过程，都须要造轮子，车身，喷漆，这个流程是“稳定的”，可是具体实现的细节是不一样的，假设咱们如今须要新增一个CarC类，那么就须要从新再实现一遍上述的流程,在实现的过程当中存在出错的可能（CarC建立时缺乏部分部件的建立方法），而且客户端还须要知道产品的建立过程（致使耦合度高），此时咱们就可使用建造者模式，此时用户只须要指定构造的类型，而不须要了解细节。

建造者模式：将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。下面咱们来看建造者模式下的例子

汽车类，由多个部件组成

//产品类
public class Car {

    List<String> list = new ArrayList<>();

    //添加Car的部件
    public void build(String string){
        list.add(string);
    }

    //展现全部产品部件
    public void show(){
        for(String string : list){
            System.out.println(string);
        }
    }

}

 

Builder接口，定义汽车由三个部件组成，以及一个展现汽车的方法。

//Builder接口，定义制造汽车的步骤
public interface Builder {

    void makeWheels();

    void makeCarBody();

    void sprayPaint();

    //定义展现Car的方法
    Car showCar();

}

//具体的建造类A
public class BuildCarA implements Builder {

    Car car = new Car();

    @Override
    public void makeWheels() {
        car.build("制造CarA的轮子");
    }

    @Override
    public void makeCarBody() {
        car.build("制造车CarA车身");
    }

    @Override
    public void sprayPaint() {
        car.build("给CarA喷漆");
    }

    @Override
    public Car showCar() {
         return car;
    }
}

//具体的建造类B
public class BuildCarB implements Builder {

    Car car = new Car();

    @Override
    public void makeWheels() {
        car.build("制造CarB的轮子");
    }

    @Override
    public void makeCarBody() {
        car.build("制造车CarB车身");
    }

    @Override
    public void sprayPaint() {
        car.build("给CarB喷漆");
    }

    @Override
    public Car showCar() {
        return car;
    }
}

 

Director类，指挥者类，客户端经过此类来建造产品而无需知道细节。

//指挥者类 用来指挥建造过程
public class Director {
    public void Construct(Builder builder){
        builder.makeWheels();
        builder.makeCarBody();
        builder.sprayPaint();
    }
}

 

测试类 

public class Test2 {
    public static void main(String[] args) {
        Director director = new Director();
        Builder buildCarA = new BuildCarA();
        Builder buildCarB = new BuildCarB();

        //经过指挥者来建造产品
        director.Construct(buildCarA);
        Car carA = buildCarA.showCar();
        carA.show();

        director.Construct(buildCarB);
        Car carB = buildCarB.showCar();
        carB.show();
    }
}

测试结果：

制造CarA的轮子
制造车CarA车身
给CarA喷漆
制造CarB的轮子
制造车CarB车身
给CarB喷漆

　　总结：对于建立过程复杂，而且建立过程由客户端控制（此设计问题见Test），每次客户端建立产品时都会使用重复操做（此设计问题见Test），并有可能缺乏步骤（经过建造者模式的Builder接口避免此状况），或者产品对象是可变化时（见BuildCarA，BuildCarB，），咱们可使用建造者模式。经过这种模式使客户端和产品分离，建立内部构建方法稳定，可是实现细节不一样的对象。