读前辈的大话设计模式（十）之建造者模式，抒自己的读后感

建造者模式：将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以常见不同的表示。

建造者模式结构：

Builder：抽象类，是为创建一个Product对象的各个部件指定的抽象接口，接口中定义了多个创建对象各部件的功能的抽象方法；

Director：指挥者，是构建一个使用Builder接口的对象；

ConcreteBuilder：具体的建造者类，实现Builder接口，实现抽象类中的方法，构造和装备各个部件；

Product：具体产品。

如果需要即将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示意图时，我们可以使用建造者模式，又叫生成器模式。如果我们使用了建造者模式，那么用户就只需要指定需要建造的类型就可以得到它们。而具体建造的过程和细节就不需要知道了。

如果看上面的说明不清楚那么我们来试一下看代码结构，或许就能理解了。

1、新建Builder类：

package abstractclass;

import product.Product;

/**
 * Created by Administrator on 2017/8/6.
 */
public abstract class Builder {

    /**
     * 定义了多个创建对象各部件的功能的抽象方法
     */
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}

2、定义产品类，有多个部件组成：

package product;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2017/8/6.
 */
public class Product {

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

    public void add(String part){
        parts.add(part);
    }

    public void show(){
        System.out.println("产品创建：");
        for (String part: parts) {
            System.out.println(part);

        }
    }

}

3、定义具体建造者类：

package concreteclass;

import abstractclass.Builder;
import product.Product;

/**
 * Created by Administrator on 2017/8/6.
 */
public class ConcreteBuilder1 extends Builder {

    Product product = new Product();
    
    //具体建造方法
    public void buildPartA() {
        product.add("部件A");
    }

    //具体建造方法
    public void buildPartB() {
        product.add("部件B");
    }

    //返回建造完成的产品对象
    public Product getResult() {
        return product;
    }
}

package concreteclass;

import abstractclass.Builder;
import product.Product;

/**
 * Created by Administrator on 2017/8/6.
 */
public class ConcreteBuilder2 extends Builder {

    Product product = new Product();

    //具体建造方法
    public void buildPartA() {
        product.add("部件C");
    }

    //具体建造方法
    public void buildPartB() {
        product.add("部件D");
    }

    //返回建造完成的产品对象
    public Product getResult() {
        return product;
    }
}

4、定义指挥类：

package controller;

import abstractclass.Builder;

/**
 * Created by Administrator on 2017/8/6.
 */
public class Director {

    /**
     * 定义指挥建造产品的方法，参数采用多态的方式传入需要的建造具体的那种产品
     * @param builder 具体建造类对象
     */
    public void construct(Builder builder){
        
        //根据传入的参数，调用具体产品对应的具体建造方法
        builder.buildPartA();
        builder.buildPartB();

    }
}

5、定义测试类：

import abstractclass.Builder;
import concreteclass.ConcreteBuilder1;
import concreteclass.ConcreteBuilder2;
import controller.Director;
import org.junit.Test;
import product.Product;

/**
 * Created by Administrator on 2017/8/6.
 */
public class TestBuilder {

    @Test
    public void testBuilder(){
        Director director = new Director();
        Builder b1 = new ConcreteBuilder1();
        Builder b2 = new ConcreteBuilder2();

        director.construct(b1);
        Product p1 = b1.getResult();
        p1.show();

        director.construct(b2);
        Product p2 = b2.getResult();
        p2.show();

    }
}

看完代码是不是感觉清楚很多了，建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式。

嗯，至此我们基本介绍完建造者模式了。

读前辈的大话设计模式（十）之建造者模式，抒自己的读后感

猜你喜欢