设计模式之建造者模式详解(附源代码)

2018-02-27 11:45:29来源:https://www.jianshu.com/p/08cb420c4f12作者:thorhill人点击

分享





建造者模式
建造者模式
建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
介绍

意图:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。
主要解决:主要解决在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。
何时使用: 一些基本部件不会变,而其组合经常变化的时候。
如何解决:将变与不变分离开。
关键代码:建造者:创建和提供实例,导演:管理建造出来的实例的依赖关系。
角色:


builder:为创建一个产品对象的各个部件指定抽象接口。
ConcreteBuilder:实现Builder的接口以构造和装配该产品的各个部件,定义并明确它所创建的表示,并提供一个检索产品的接口。
Director:构造一个使用Builder接口的对象。
Product:表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程,包含定义组成部件的类,包括将这些部件装配成最终产品的接口。

优点:


建造者独立,易扩展。
便于控制细节风险。

缺点:


产品必须有共同点,范围有限制。
如内部变化复杂,会有很多的建造类

使用场景:


需要生成的对象具有复杂的内部结构。
需要生成的对象内部属性本身相互依赖。
注意事项:与工厂模式的区别是:建造者模式更加关注与零件装配的顺序。
实现:

听说最近人工智能可以写作了,那么这里我们也写一个能自动造句的人工智障智能,叫做鹏酱。鹏酱可以造主谓宾结构的句子。代码如下:


一、建造变动较小较慢的组件

1.主语系列(subject)


/**
*
* @author Thornhill
* @see 主语的接口
*/
public interface Subject {
public void showSbuject();
}
/**
*
* @author Thornhill
* @see 主语“做饭”
*/
public class Cook implements Subject {
@Override
public void showSbuject() {
System.out.print("做饭");
}
}
/**
*
* @author Thornhill
* @see 主语“编程”
*/
public class Coding implements Subject {
@Override
public void showSbuject() {
System.out.print("编程");
}
}

2.谓语系列(predicate)


/**
*
* @author Thornhill
* @see 谓语接口
*/
public interface Predicate {
public void showPredicate();
}

/**
*
* @author Thornhill
* @see 谓语“是”
*/
public class Is implements Predicate {
@Override
public void showPredicate() {
System.out.print("是");
}
}
/**
*
* @author Thornhill
* @see 谓语“不是”
*/
public class IsNot implements Predicate {
@Override
public void showPredicate() {
System.out.print("不是");
}
}

3.宾语系列(object)


/**
*
* @author Thornhill
* @see "宾语接口"
*/
public interface Object {
public void showObject();
}
/**
*
* @author Thornhill
* @see 宾语“简单”
*/
public class Easy implements Object {
@Override
public void showObject() {
System.out.println("简单的");
}
}
/**
*
* @author Thornhill
* @see 宾语“困难”
*/
public class Difficult implements Object {
@Override
public void showObject() {
System.out.println("困难的");
}
}

二、建造不会变动的产品(Product)框架
/**
*
* @author Thornhill
* @see 产品框架(Product)
*/
public class ChickenSoup {
private Subject subject;
private Predicate predicate;
private Object object;
public Subject getSubject() {
return subject;
}
public void setSubject(Subject subject) {
this.subject = subject;
}
public Predicate getPredicate() {
return predicate;
}
public void setPredicate(Predicate predicate) {
this.predicate = predicate;
}
public Object getObject() {
return object;
}
public void setObject(Object object) {
this.object = object;
}
public void showChickenSoup() {
subject.showSbuject();
predicate.showPredicate();
object.showObject();
}
}

三、建造Builder接口:
/**
*
* @author Thornhill
* @see 鸡汤文章的接口(Builder)
*/
public interface EssayBuilder {
public void setEssaySubject();
public void setEssayPredicate();
public void setEssayObject();
public ChickenSoup getEssay();
}

四、建造实现Builder接口的具体生成器(ConcreteBuilder):
/**
*
* @author Thornhill
* @see 构造“做饭简单”的具体生成器
*/
public class CookingIsEasy implements EssayBuilder {
private ChickenSoup chickenSoup = new ChickenSoup();
@Override
public void setEssaySubject() {
chickenSoup.setSubject(new Cook());
}
@Override
public void setEssayPredicate() {
chickenSoup.setPredicate(new Is());
}
@Override
public void setEssayObject() {
chickenSoup.setObject(new Easy());
}
@Override
public ChickenSoup getEssay() {
return chickenSoup;
}
}
/**
*
* @author Thornhill
* @see 构造“编程不难”的具体生成器
*/
public class CodingIsNotDiffcult implements EssayBuilder {
private ChickenSoup chickenSoup = new ChickenSoup();
@Override
public void setEssaySubject() {
chickenSoup.setSubject(new Coding());
}
@Override
public void setEssayPredicate() {
chickenSoup.setPredicate(new IsNot());
}
@Override
public void setEssayObject() {
chickenSoup.setObject(new Difficult());
}
@Override
public ChickenSoup getEssay() {
return chickenSoup;
}
}

五、建造通过Builder接口,按照顺序调用ConcreteBuilder的导演(Director):
/**
*
* @author Thornhill
* @see 调用具体生成器的“导演”类
*/
public class EssayDirector {
public ChickenSoup getFinalEssay(EssayBuilder eb) {
eb.setEssayObject();
eb.setEssayPredicate();
eb.setEssaySubject();
return eb.getEssay();
}
}

六、测试:
/**
*
* @author Thornhill
* @see 建造者模式测试
*/
public class Test {
public static void main(String[] args) {
ChickenSoup essay1 = new EssayDirector().getFinalEssay(new CookingIsEasy());
essay1.showChickenSoup();

ChickenSoup essay2 = new EssayDirector().getFinalEssay(new CodingIsNotDiffcult());
essay2.showChickenSoup();

}
}

结果:


做饭是简单的
编程不是困难的

结语:
建造者模式适用于组建不变而组合常有变动的情景。产品(Product),抽象接口(Builder),导演(Director)通常是不用变的部分;而具体生成器(ConcreteBuilder)是扩展时增加的部分,通常改动只改动具体生成器。

GitHub源代码








最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台