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，），咱們可使用建造者模式。經過這種模式使客戶端和產品分離，建立內部構建方法穩定，可是實現細節不一樣的對象。