java设计模式五之Builder建造者设计模式

前言：

     Builder建造者设计模式，用来隐藏复合对象的创建过程，把复合对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

     我感觉比较明显的一个优点是：把对象创建和业务代码分离，代码清晰易懂，便于代码的维护，不用把复杂的对象创建过程融合到业务逻辑代码中。

怎么实现？

   1.有一个复合的对象,称之为product，最终要创建的产品。

   2.抽象建造者，利用多态的特性，用来接收真实建造者。

   3.真实建造者，用来创建一个具体的复合对象及各个属性，及返回对象的方法

   4.设计师，根据建造者，设计出最终产品

代码：

  创建房子实体类House:

package com.xhx.designpattern.entity;

public class House {
    private String floor;
    private String wall;
    private String housetop;

    public String getFloor() {
        return floor;
    }

    public void setFloor(String floor) {
        this.floor = floor;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getHousetop() {
        return housetop;
    }

    public void setHousetop(String housetop) {
        this.housetop = housetop;
    }
}

如果直接建房子：

//直接造房子
//        House house=new House();
//        house.setFloor("地板");
//        house.setHousetop("房顶");
//        house.setWall("墙");

上面这个代码肯定不是咱们想要的，如果house对象更加复杂，直接写在业务代码里或者是在业务类中抽出一个方法，简直都不能忍。

创建一个建造房子的接口：

package com.xhx.designpattern;

import com.xhx.designpattern.entity.House;

/**
 * 工程队
 */
public interface HouseBuilder {

    //修地板
    public void makeFloor();

    //修墙
    public void makeWall();

    //修屋顶
    public void makeHousetop();

    public House getHouse();
}

下面建造者 建平房：

package com.xhx.designpattern;

import com.xhx.designpattern.entity.House;

/**
 * 平房工程队
 */
public class PingFangBuilder implements HouseBuilder{
   House house = new House();

    @Override
    public void makeFloor() {
        house.setFloor("平房-->地板");
    }

    @Override
    public void makeWall() {
        house.setWall("平房-->墙");
    }

    @Override
    public void makeHousetop() {
        house.setHousetop("平房-->房顶");
    }

    @Override
    public House getHouse() {
        return house;
    }
}

如果由建造者建房子：

        //HouseBuilder builder = new PingFangBuilder();
//        builder.makeFloor();
//        builder.makeHousetop();
//        builder.makeWall();

这样也不好，业务逻辑代码中都是makeXXX，和上面直接建房子（setXXX）没区别

下面创建一个房子设计师：

package com.xhx.designpattern;

public class HouseDirecter {

    //其实也没必要加一个属性，构造函数传参，
    //makeHourse方法加个入参HouseBuilder 就可以了
    private HouseBuilder builder;

    public HouseDirecter(HouseBuilder builder){
        this.builder=builder;
    }

    public void makeHourse(){
        builder.makeFloor();
        builder.makeWall();
        builder.makeHousetop();
    }
}

下面由设计师来造房子：

        HouseBuilder builder = new PingFangBuilder();
        HouseDirecter directer = new HouseDirecter(builder);
        directer.makeHourse();

看一下这三种造房子主方法：

package com.xhx.designpattern;

import com.xhx.designpattern.entity.House;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        //直接造房子
//        House house=new House();
//        house.setFloor("地板");
//        house.setHousetop("房顶");
//        house.setWall("墙");

        //由工程对来修
        //HouseBuilder builder = new PingFangBuilder();
        HouseBuilder builder = new GongyuBuilder();
//        builder.makeFloor();
//        builder.makeHousetop();
//        builder.makeWall();


        //由设计者来做
        HouseDirecter directer = new HouseDirecter(builder);
        directer.makeHourse();
        House house = builder.getHouse();

        System.out.println(house.getFloor());
        System.out.println(house.getHousetop());
        System.out.println(house.getWall());
    }
}

建造者设计模式其实就是把创建复杂对象的过程一步一步抽取出来，封装到外面的类中。

我的github地址