Java设计模式:建造者模式

在日常开发中,如果遇到日常需求为:
①需要建房子:过程为打地基、砌墙、封顶;
②能够实现不同类型房子对建造过程的复用。

那么我们应该如何实现这个需求呢?首先我们先画出UML的关系图如下:
UML关系图
以一个抽象类作为父类,抽象的声明建造房子的方法,具体实现类则作为子类来实现抽象类,Client类则负责创建。

//抽象父类
public abstract class AbstractBuilding {
    public abstract void base();
    public abstract void wall();
    public abstract void roof();
    public void build(){
        base();
        wall();
        roof();
    }
}
//具体实现类
public class CommonBuilding extends AbstractBuilding{
    @Override
    public void base() {
        System.out.println("普楼打地基");
    }
    @Override
    public void wall() {
        System.out.println("普楼砌墙");
    }
    @Override
    public void roof() {
        System.out.println("普楼封顶");
    }
}
//具体实现类
public class HighBuilding extends AbstractBuilding{
    @Override
    public void base() {
        System.out.println("高楼打地基");
    }
    @Override
    public void wall() {
        System.out.println("高楼砌墙");
    }
    @Override
    public void roof() {
        System.out.println("高楼封顶");
    }
}
public class Client {
    public static void main(String[] args) {
        CommonBuilding commonBuilding = new CommonBuilding();
        commonBuilding.build();
        HighBuilding highBuilding = new HighBuilding();
        highBuilding.build();
    }
}

这种写法的有点是简单易懂,可是这种程序结构简单,扩展与维护起来较困难,耦合性比较强。
于是我们使用建造者模式替代。

对建造者模式的基本介绍:

1.它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。
2.建造者模式 是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节

建造者模式的四个角色:

  1. Product(产品角色): 一个具体的产品对象。
  2. Builder(抽象建造者): 创建一个Product对象的各个部件指定的 接口/抽象类。
  3. ConcreteBuilder(具体建造者): 实现接口,构建和装配各个部件。
  4. Director(指挥者): 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用,一是:隔离了客户与对象的生产过程,二是:负责控制产品对象的生产过程。

UML关系图如下:
在这里插入图片描述
Building是产品,将其封装为一个Bean

public class Building {
    private String base;
    private String wall;
    private String roof;
    public String getBase() {
        return base;
    }
    public void setBase(String base) {
        this.base = base;
    }
    public String getWall() {
        return wall;
    }
    public void setWall(String wall) {
        this.wall = wall;
    }
    public String getRoof() {
        return roof;
    }
    public void setRoof(String roof) {
        this.roof = roof;
    }
}

Builder类作为抽象类,内部声明产品与抽象方法:

//抽象的建造者
public abstract class Builder {
    protected Building building = new Building();
    //抽象建造的流程
    public abstract void baseBuild();
    public abstract void wallBuild();
    public abstract void roofBuild();
    //返回房子
    public Building getBuilding(){
        return building;
    }
}

CommonBuilding类作为具体实现类,继承Builder父类,实现抽象父类的方法(同为实现类的HighBuilding写法一致,这里省略):

public class CommonBuilding extends Builder{
    @Override
    public void baseBuild() {
        System.out.println("普楼打地基——小型");
    }
    @Override
    public void wallBuild() {
        System.out.println("普楼砌墙——小型");
    }
    @Override
    public void roofBuild() {
        System.out.println("普楼封顶——小型");
    }
}

建造指挥官,通过传入Builder对象,调用对象实现具体方法,仅仅负责实现建造的步骤,不关心建造的具体实现,返回最终产品:

public class BuildingDirector {
    Builder builder = null;
    //构造器传入
    public BuildingDirector(Builder builder){
        this.builder = builder;
    }
    //setter方法传入
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }
    //指挥者负责建造的过程管控
    public Building constructBuilding(){
        builder.baseBuild();
        builder.wallBuild();
        builder.roofBuild();
        return builder.getBuilding();
    }
}

客户端调用:

public class Client {
    public static void main(String[] args) {
        CommonBuilding commonBuilding = new CommonBuilding();
        BuildingDirector buildingDirector = new BuildingDirector(commonBuilding);
        //产品房子
        Building building = buildingDirector.constructBuilding();
    }
}

总结

掌握建造者模式需要记住建造者模式的四个角色,每个角色有每个角色负责的内容,达到解耦的实际效果。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值