当前位置: 七九推 > IT编程>软件设计>设计模式 > 创建型模式:建造者模式

创建型模式:建造者模式

2022年06月15日 设计模式 我要评论
个人公众号原文:创建型模式:建造者模式五大创建型模式之四:建造者模式。简介姓名 :建造者模式英文名 :builder pattern价值观 :专治丢三落四个人介绍 :separate the cons

个人公众号原文:
创建型模式:建造者模式

景

五大创建型模式之四:建造者模式。

简介

姓名 :建造者模式

英文名 :builder pattern

价值观 :专治丢三落四

个人介绍

separate the construction of a complex object from its representation so that the same construction process can create different representations.
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
(来自《设计模式之禅》)

今天给大家介绍的是建造者模式。建造者模式的使用场景是:创建复杂的对象。什么才能算复杂对象?如果一个对象只需要通过 new xxx() 的方式创建,那就算是一个简单对象;如果需要 new xxx(),并且还要设置很多属性,那这种就可以称为复杂对象了,因为它的构建过程比较复杂。采用建造者模式,可以把这个复杂的构建过程抽离开,使它不依赖创建者。下面我们通过故事来讲解。

你要的故事

还记得小时候刚开始学煮汤,不了解怎么煮,第一次是煮了板栗排骨汤,因为板栗比较难熟,所以是跟排骨一起下锅,然后煮了 40 分钟,加了盐就可以出锅啦。第二次煮了冬瓜排骨汤,不懂得冬瓜容易熟,就和排骨一起下锅,煮了也差不多 40 分钟,下了盐和香菜,发现怎么这汤有点浓,冬瓜咋都不见了(全都煮透了),我妈看到这锅汤,才跟我说冬瓜容易熟,得先熬排骨,再放冬瓜进去煮。那时才发现熬汤特么还有这差异。

上面是背景哈,接下来我们来实现这个煲汤过程,冬瓜排骨汤是先加排骨,熬制 30 分钟,加冬瓜,熬制 18 分钟,加盐加香菜;板栗排骨汤是先加排骨和板栗,熬制 40 分钟,再加盐。这汤都需要加肉、加菜、熬制、加配料。我们使用下面代码实现这个煲冬瓜排骨汤和板栗排骨汤的过程。

public class nobuildertest {

    public static void main(string[] args) {
        // 熬制冬瓜排骨汤
        dongguapaigusoup dongguapaigusoup = new dongguapaigusoup();
        // 加排骨
        dongguapaigusoup.addmeat();
        // 熬制 30 分钟
        dongguapaigusoup.waitminute(30);
        // 加冬瓜
        dongguapaigusoup.addvegetables();
        // 熬制 10 分钟
        dongguapaigusoup.waitminute(10);
        // 加盐加香菜
        dongguapaigusoup.addingredients();

        // 熬制板栗排骨汤
        banlipaigusoup banlipaigusoup = new banlipaigusoup();
        // 加排骨
        banlipaigusoup.addmeat();
        // 加板栗
        banlipaigusoup.addvegetables();
        // 熬制 40 分钟
        banlipaigusoup.waitminute(40);
        // 加盐
        banlipaigusoup.addingredients();
    }

}

/**
 * 煲汤接口
 */
interface soup {

    /** 加肉 */
    void addmeat();
    /** 加菜 */
    void addvegetables();
    /** 熬制 */
    void waitminute(int minute);
    /** 加配料 */
    void addingredients();

}

/**
 * 冬瓜排骨汤
 */
class dongguapaigusoup implements soup {

    @override
    public void addmeat() {
        system.out.println("加排骨");
    }

    @override
    public void addvegetables() {
        system.out.println("加冬瓜");
    }

    @override
    public void waitminute(int minute) {
        system.out.println("熬制 " + minute + " 分钟");
    }

    @override
    public void addingredients() {
        system.out.println("加盐、加香菜");
    }
}

/**
 * 板栗排骨汤
 */
class banlipaigusoup implements soup {

    @override
    public void addmeat() {
        system.out.println("加排骨");
    }

    @override
    public void addvegetables() {
        system.out.println("加板栗");
    }

    @override
    public void waitminute(int minute) {
        system.out.println("熬制 " + minute + " 分钟");
    }

    @override
    public void addingredients() {
        system.out.println("加盐");
    }
}

上面代码简单实现了煲冬瓜排骨汤和板栗排骨汤。煲汤我们要关注的点是:各操作的顺序,是先加肉先煮再加菜,还是肉和菜一起放进锅煮。上面代码中,这个过程是谁控制的?是煲汤的人,所以顺序由煲汤的人决定,甚至有可能忘记放配料啥的,这样子的汤就味道不够好。那怎么去解决这些问题?

我们通过建造者模式可以解决上面的 2 个问题:煲汤顺序问题和忘记加配料这种丢三落四行为。我们将这个煲汤顺序从煲汤者分离开来,让煲汤者只需要决定煲什么汤就好,让建造者来保证煲汤顺序问题和防止漏加配料。

我们用一个 soupbuilder 来规范化煲汤过程,方法 buildsoup 给实现者提供一个设置煲汤顺序的地方。因为冬瓜排骨汤和板栗排骨汤熬制的过程不一样,所以分别用 dongguapaigusoupbuilder 和 banlipaigusoupbuilder 来具体实现冬瓜排骨汤和板栗排骨汤的熬制过程,也就是消除熬制过程和煲汤者的依赖关系。 director 则相当于一个菜单,提供为熬汤者来选择熬什么汤。具体代码如下所示。

public class buildertest {

    public static void main(string[] args) {
        director director = new director();
        // 熬制冬瓜排骨汤
        director.builddongguapaigusoup();
        // 熬制板栗排骨汤
        director.buildbanlipaigusoup();
    }

}

/**
 * 煲汤建造接口
 */
interface soupbuilder {
    void buildsoup();
    soup getsoup();
}

/**
 * 冬瓜排骨汤建造者
 */
class dongguapaigusoupbuilder implements soupbuilder {

    private dongguapaigusoup dongguapaigusoup = new dongguapaigusoup();

    @override
    public void buildsoup() {
        // 加排骨
        dongguapaigusoup.addmeat();
        // 熬制 30 分钟
        dongguapaigusoup.waitminute(30);
        // 加冬瓜
        dongguapaigusoup.addvegetables();
        // 熬制 10 分钟
        dongguapaigusoup.waitminute(10);
        // 加盐加香菜
        dongguapaigusoup.addingredients();
    }

    @override
    public soup getsoup() {
        return dongguapaigusoup;
    }
}

/**
 * 板栗排骨汤建造者
 */
class banlipaigusoupbuilder implements soupbuilder {

    banlipaigusoup banlipaigusoup = new banlipaigusoup();

    @override
    public void buildsoup() {
        // 加排骨
        banlipaigusoup.addmeat();
        // 加板栗
        banlipaigusoup.addvegetables();
        // 熬制 40 分钟
        banlipaigusoup.waitminute(40);
        // 加盐
        banlipaigusoup.addingredients();
    }

    @override
    public soup getsoup() {
        return banlipaigusoup;
    }
}

/**
 * 生产方
 */
class director {
    private dongguapaigusoupbuilder dongguapaigusoupbuilder = new dongguapaigusoupbuilder();
    private banlipaigusoupbuilder banlipaigusoupbuilder = new banlipaigusoupbuilder();

    /**
     * 熬制冬瓜排骨汤
     */
    public dongguapaigusoup builddongguapaigusoup() {
        dongguapaigusoupbuilder.buildsoup();
        return (dongguapaigusoup) dongguapaigusoupbuilder.getsoup();
    }

    /**
     * 熬制板栗排骨汤
     */
    public banlipaigusoup buildbanlipaigusoup() {
        banlipaigusoupbuilder.buildsoup();
        return (banlipaigusoup) banlipaigusoupbuilder.getsoup();
    }

}

通过用建造者实现,是不是保证了熬制汤的顺序并且一定会加够料?感受一下其中的奥秘吧。

代码:
builder pattern

总结

通过建造者模式,可以把本来强依赖的东西解绑,不仅仅解决依赖问题,还提高了封装性,让使用者不用明白内部的细节,用上面的例子说就熬汤不用关心怎么熬制的过程,就像我们想喝冬瓜排骨汤,告诉妈妈,妈妈熬制,我们并不知道是怎么熬制的。

参考资料:《大话设计模式》、《java设计模式》、《设计模式之禅》、《研磨设计模式》、《head first 设计模式》

推荐阅读:
创建型模式:单例模式
创建型模式:工厂方法
创建型模式:抽象工厂
公众号之设计模式系列文章

希望文章对您有所帮助,设计模式系列会持续更新,感兴趣的同学可以关注公众号:liebrother,第一时间获取文章推送阅读,也可以一起交流,交个朋友。

公众号

(0)
打赏 微信扫一扫 微信扫一扫

相关文章:

版权声明:本文内容由互联网用户贡献,该文观点仅代表作者本人。本站仅提供信息存储服务,不拥有所有权,不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 2386932994@qq.com 举报,一经查实将立刻删除。

发表评论

验证码:
Copyright © 2017-2022  七九推 保留所有权利. 粤ICP备17035492号
站长QQ:2386932994 | 联系邮箱:2386932994@qq.com