LieBrother

当才华撑不起野心时,应该静下心来学习;当能力驾驭不了目标时,应该沉下心来历练。


  • 首页

  • 归档

  • 分类

  • 标签

  • 关于

行为型模式:模板方法

发表于 2019-02-17   |     |   阅读次数

LieBrother公众号原文:
行为型模式:模板方法

景

十一大行为型模式之一:模板方法。

简介

姓名 :模板方法

英文名 :Template Method Pattern

价值观 :在我的掌控下,任由你发挥

个人介绍 :

Define the skeleton of an algorithm in an operation,deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.
定义一个操作中的算法的框架,而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
(来自《设计模式之禅》)

解释一下上面的介绍,意思是由父类来定义框架,让子类来具体实现。

你要的故事

刚过完春节,大家都买新鞋了么?今天要讲的故事和鞋子有关。一双鞋子从表面来看,由鞋底、鞋垫、鞋面、鞋带组成,同一系列的鞋子这几个部分都是一样的,用同样的材料做出来,不同系列的鞋子就大相径庭了。根据模板方法模式,组装一双鞋子的制造过程可以归并为固定的框架,至于用什么材料,那由每个系列的鞋子去具体实现。我们先看定义组装鞋子的框架代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* 定义鞋子制造的工序框架
*/
abstract class ShoeInstallTemplate {

public abstract void installSole();
public abstract void installInsole();
public abstract void installVamp();
public abstract void installShoelace();

public void installShot(){
System.out.println("组装一双鞋,步骤如下:");
// 组装鞋底
installSole();
// 组装鞋垫
installInsole();
// 组装鞋面
installVamp();
// 组装鞋带
installShoelace();
}

}

定义了一个组装鞋子框架的抽象类 ShoeInstallTemplate,里面有 4 个工序未具体实现,由鞋子制造商去实现,因为只有鞋子制造商才知道鞋子要用什么材料来做。
下面举 2 个比较出名的鞋子:Adidas 的 Boost 系列和 Nike 的 Jordan 系列。下面分别实现这 2 个系列鞋子的制造代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
* Adidas Boost 鞋制造
*/
class AdidasBoostShoeInstall extends ShoeInstallTemplate {
@Override
public void installSole() {
System.out.println("组装白色 Boost 鞋底");
}

@Override
public void installInsole() {
System.out.println("组装黑色 Boost 鞋垫");
}

@Override
public void installVamp() {
System.out.println("组装黑色 Boost 鞋面");
}

@Override
public void installShoelace() {
System.out.println("组装黑色 Boost 鞋带");
}
}

/**
* Nike Jordan 鞋制造
*/
class NikeJordanShoeInstall extends ShoeInstallTemplate {

@Override
public void installSole() {
System.out.println("组装黑色 Jordan 鞋底");
}

@Override
public void installInsole() {
System.out.println("组装黑色 Jordan 鞋垫");
}

@Override
public void installVamp() {
System.out.println("组装红色 Jordan 鞋面");
}

@Override
public void installShoelace() {
System.out.println("组装红色 Jordan 鞋带");
}
}

实现了制造商制造鞋子的代码之后,我们通过代码测试怎么制造 Boost 和 Jordan 鞋子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TemplateMethodTest {

public static void main(String[] args) {
ShoeInstallTemplate adidasBoost = new AdidasBoostShoeInstall();
adidasBoost.installShot();

ShoeInstallTemplate nikeJordan = new NikeJordanShoeInstall();
nikeJordan.installShot();
}

}

打印结果:
组装一双鞋,步骤如下:
组装白色 Boost 鞋底
组装黑色 Boost 鞋垫
组装黑色 Boost 鞋面
组装黑色 Boost 鞋带

组装一双鞋,步骤如下:
组装黑色 Jordan 鞋底
组装黑色 Jordan 鞋垫
组装红色 Jordan 鞋面
组装红色 Jordan 鞋带

模板方法模式就这么简单。是不是掌握了?

代码:
Template Method Pattern

总结

模板方法是一个比较实用的模式,为什么说实用呢?举个现实的例子,Java 能有如今的发展,离不开各大开源框架,比如 Dubbo,有看过源码的朋友就知道,里面大量代码运用了模板方法设计模式,为什么 Dubbo 可以支持很多种注册中心?其实本质就是用了模板方法设计模式,使得可以扩展多种注册中心。掌握好模板方法,对读源码有非常大的帮助,很多人包括我在内,在刚开始阅读源码的时候,有相当长的一段时间怀疑人生,怎么这些代码那么绕?调来调去的。当你了解了常用的设计模式之后,看源代码就可以直截了当的知道是用什么设计模式,为什么用这个设计模式?原来是为了什么什么。。。有了这层思考,就像有一条线将以前散落在各地的知识点连接起来,成了可以推敲的知识。

参考资料:《大话设计模式》、《设计模式之禅》

推荐阅读:

设计模式系列文章

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

公众号

猪年感受

发表于 2019-02-14   |     |   阅读次数

景色

猪年真正到来啦!给自己放了一个长长的假,直到今天上班都还没怎么精神。不知道大家这个年过得怎么样,是不是都回老家了?老家有什么变化么?我来说说我看到的变化,大家也可以畅谈过年的感受。

路通则人达

回到家乡,停滞了八年之久的沿江路终于通车了。现在的老家在往城市化发展,路已经四通八达,不再是当年江对面的灯光闪耀和江这边的乱草丛生形成明显对比的景象,作为后来发展的小镇,路更大了,景更美了。

国泰民安?

今年发现的最让我诧异的是:摩托车、单车像汽车一样,居然放在门口过夜。我还清晰的记得初中那会,家里的一台很破旧的电脑在一个下午被贼入室偷走了。我爸一朋友晚上一家人在家里睡觉,被贼入室偷走了 2 台摩托车。小时候经常听父母说他们那个年代家里的门都没锁的,晚上不关门也没事,因为大家都一样,一清二白。难道已经到了大家都一样:有钱?显然不是,村里还有人骑不起摩托车呢。这段时间只要有闲暇时间,就会思考这个问题。我总结有如下原因,欢迎大家一起思考这个问题,留言讨论。

1.国民素质在整体提高。就我们村里这个小范围的人群,贼依旧是那几个,他们终究敌不过岁月,该坐牢的也坐了,年轻人越来越多干正业。

2.赚钱的途径多了,钱也就容易赚了。小时候不读书,大人就会说那就去工厂打工,现在已经不是只能去工厂打工的日子了,甚至游戏都可以赚很多钱,我一同学到现在依旧在靠打梦幻西游赚钱。

3.做贼的成本太高。薛兆丰老师的经济学课讲过:成本是放弃了的最大代价,如果没什么可放弃,也就不存在成本。怎么理解呢?让你去做贼和去工作,你怎么选呢?选择做贼的成本就是放弃了工作赚钱;选择工作的成本就是放弃了做贼。从第二点中说了现在工作赚钱不仅仅指打工,还可以玩游戏、做直播等等,所以放弃工作赚钱更难了,也就是做贼的成本更高了。明白人都知道该怎么选,是吧?

饮食行业兴起

过年前就和老姐她们几个人商量回老家要吃哪里的宵夜,回到家才体会到饮食行业如此赚钱,就连除夕夜、大年初一,各大宵夜档都没关,仍然营业。关键在于去吃的人特别多,每晚都得排队半个小时以上。和朋友在吃宵夜的时候粗略算了一下每晚老板的收入,得出结论:咱辛辛苦苦在深圳干一年还不如宵夜档老板干春节这半个月。很惨痛的事实,但是这些老板他们值得这些收入,他们大过年的也不休息,甚至过年人更多更累,一如既往地干同样的活。我们应该从中反思一下,在他们身上发掘你需要学习的东西。

聚会更难了

咱们在外工作,回老家过年除了陪伴家人和走亲戚,还有一项就是和老朋友聚会。今年发现想要十几个人都有时间一起聚很难,大家各有各忙的,只能小范围聚会。能预见到以后会更难聚。

以上就是这次春节所感受到的。在感受中学会生活。

今天刚好是情人节,祝各位有情人的情人节快乐!没情人的转眼就找到情人!



公众号

创建型模式:原型模式

发表于 2019-01-27   |     |   阅读次数

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

景

五大创建型模式之五:原型模式。

简介

姓名 :原型模式

英文名 :Prototype Pattern

价值观 :效率第一

个人介绍 :

Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
(来自《设计模式之禅》)

又到了一个系列的最后一篇文章了,今天是创建型模式的最后一篇。什么是创建型模式呢?创建型模式是对类的实例化过程进行抽象,使对象的创建和使用分离,从而使代码更加灵活。

我们平时使用最多的一种创建对象方式就是 new ABC(),直接通过构造方法来创建一个对象。通过原型模式来创建对象则不用调用构造方法,就可以创建一个对象。下面来揭开它的面纱。

你要的故事

前几天有出版社的老师邀请写书,鉴于深知自己水平还不足以出书,所以没有合作,还在努力学习,以后有能力有机会再考虑这方面的事情。

今天的故事就从出书讲起。我们知道一本新书发版的时候,会复印很多册,如果销售得好,会有很多个印刷版本。我们来了解复印一批书籍这个过程是怎么实现的。小明写下了下面这段代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
public class NoPrototypeTest {

public static void main(String[] args) {
for (int i = 1; i <= 10; i ++) {
Book book = new Book("娱乐至死", "尼尔波兹曼", "社会科学", "XXXX");
System.out.println("复印书籍:" + book.getName() + ",第 " + i + " 本");
}
}

}

class Book {
private String name;
private String author;
private String type;
private String content;

public Book(String name, String author, String type, String content) {
this.name = name;
this.author = author;
this.type = type;
this.content = content;
System.out.println("实例化书籍:" + this.name);
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}

public String getContent() {
return content;
}

public void setContent(String content) {
this.content = content;
}
}

// 打印结果:
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 1 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 2 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 3 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 4 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 5 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 6 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 7 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 8 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 9 本
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 10 本

上面小明的代码复印了 10 本《娱乐至死》,代码逻辑没有问题,有个问题就是复印一本就实例化一次书籍,这个实例化可以减少么?使用原型模式可以实现。小明根据这些提示,重新修改了代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
public class PrototypeTest {

public static void main(String[] args) {
Book2 book1 = new ConcreteBook("娱乐至死", "尼尔波兹曼", "社会科学", "XXXX");
System.out.println("复印书籍:" + book1.getName() + ",第 " + 1 + " 本");
for (int i = 2; i <= 10; i ++) {
Book2 book2 = (Book2) book1.clone();
System.out.println("复印书籍:" + book2.getName() + ",第 " + i + " 本");
}


}

}

/**
* 抽象类
*/
abstract class Book2 implements Cloneable {

private String name;
private String author;
private String type;
private String content;

public Book2(String name, String author, String type, String content) {
this.name = name;
this.author = author;
this.type = type;
this.content = content;
System.out.println("实例化书籍:" + this.name);
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}

public String getContent() {
return content;
}

public void setContent(String content) {
this.content = content;
}

@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}

/**
* 具体类
*/
class ConcreteBook extends Book2 {

public ConcreteBook(String name, String author, String type, String content) {
super(name, author, type, content);
}
}

打印结果:
实例化书籍:娱乐至死
复印书籍:娱乐至死,第 1 本
复印书籍:娱乐至死,第 2 本
复印书籍:娱乐至死,第 3 本
复印书籍:娱乐至死,第 4 本
复印书籍:娱乐至死,第 5 本
复印书籍:娱乐至死,第 6 本
复印书籍:娱乐至死,第 7 本
复印书籍:娱乐至死,第 8 本
复印书籍:娱乐至死,第 9 本
复印书籍:娱乐至死,第 10 本

看,打印结果和第一次实现的结果完全不一样,这一次只实例化了一次,后面复印的书籍都没有实例化。我们看看代码的变化,代码中最最主要的就是 Book2 实现了 Cloneable 接口,这个接口有个 clone() 方法,通过实现这个方法,可以实现对象的拷贝,就是不用调用构造方法,直接通过对内存的拷贝来创建一个新的对象。这就是原型模式的实现方式,通过原型模式可以提高创建对象的效率。

代码:
Prototype Pattern

总结

通过原型模式,绕过构造方法创建对象,利用内存直接拷贝对象,提高对象的创建性效率。在有大量的对象创建或者类初始化消耗多资源的场景下可以利用原型模式来优化。当然在实现的过程中,要注意浅拷贝与深拷贝的问题,防止写出 bug,文章主要介绍原型模式,就不详细说这个问题了,留给大家去扩展了解。

参考资料:《大话设计模式》、《Java设计模式》、《设计模式之禅》、《研磨设计模式》、《Head First 设计模式》

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

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



公众号

创建型模式:建造者模式

发表于 2019-01-26   |     |   阅读次数

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

景

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

简介

姓名 :建造者模式

英文名 :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 分钟,再加盐。这汤都需要加肉、加菜、熬制、加配料。我们使用下面代码实现这个煲冬瓜排骨汤和板栗排骨汤的过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
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 则相当于一个菜单,提供为熬汤者来选择熬什么汤。具体代码如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
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

总结

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

参考资料:《大话设计模式》、《Java设计模式》、《设计模式之禅》、《研磨设计模式》、《Head First 设计模式》

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

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



公众号

寒冬储粮

发表于 2019-01-23   |     |   阅读次数

鸟儿

上次发了这篇文章 跳槽 & 思维导图,里面只是贴了一个图,也看不是很清,主要是想给大家看一下思维导图记录知识点参考一下,后面有小伙伴在咨询能否把思维导图原件分享出来,分享出来肯定是可以的,这些都不是我的知识,都是网上的资料,我只是把它们记录在思维导图。

今天把这些资料整理了,有的其实还没记录到位,还有很多遗漏的知识点,用我个人力量也很难把这些知识点都总结起来。因此,在把资料上传到百度网盘和 github 之间,我选择了后者,因为大家可以把自己觉得有用的知识点也提交上来,或者在已经存在的思维导图基础上补充进去,让大家都能学习到,也可以多多交流。

有一点想强调的:思维导图就跟人的思维一样,每个人的思维都是不一样的,所以其他人记录下来的东西不一定适合你,最好大家自己都能养成把知识点用思维导图记录的习惯,自己记录下的东西才真正属于你的。

年底了,希望大家过个好年,猪年一起牛逼。

粮食链接

目录如下:

share

推荐阅读:
公众号之设计模式系列文章



公众号

1…789…24
LieBrother

LieBrother

当才华撑不起野心时,应该静下心来学习;当能力驾驭不了目标时,应该沉下心来历练。

120 日志
38 分类
138 标签
© 2016 - 2019 LieBrother
由 Hexo 强力驱动
主题 - NexT.Mist
本站访客数人次  |  本站总访问量次