0%

图解设计模式PDF下载

《图解设计模式》

链接: https://pan.baidu.com/s/1S3jRtSGKvDVHDPP0QjApog 提取码: p3wn

本书以浅显易懂的语言逐一说明了GoF的23种设计模式。在讲解过程中,不仅搭配了丰富的图片,而且理论结合实例,用Java语言编写代码实现了设计模式的程序,让程序真正地运行起来,并提供了运用模式解决具体问题的练习题和答案。除此以外,本书在必要时还对Java语言的功能进行补充说明,以加深读者对Java的理解。

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897

目录

第1部分 适应设计模式 1

第1章 Iterator模式——一个一个遍历 1

1.1 Iterator模式 2

1.2 示例程序 2

Aggregate接口 3

Iterator接口 5

Book类 5

BookShelf类 5

BookShelfIteraotr类 6

Main类 7

1.3 Iterator模式中的登场角色 8

1.4 拓展思路的要点 9

不管实现如何变化,都可以使用Iterator 9

难以理解抽象类和接口 9

Aggregate和Iterator的对应 9

容易弄错“下一个” 10

还容易弄错 “最后一个” 10

多个Iterator 10

迭代器的种类多种多样 10

不需要deleteIterator 10

1.5 相关的设计模式 11

1.6 本章所学知识 11

1.7 练习题 11

第2章 Adapter模式——加个“适配器”以便于复用 13

2.1 Adapter模式 14

2.2 示例程序(1)(使用继承的适配器) 14

Banner类 15

Print接口 16

PrintBanner类 16

Main类 16

2.3 示例程序(2)(使用委托的示例程序) 17

Print类 18

PrintBanner类 18

2.4 Adapter模式中的登场角色 18

2.5 拓展思路的要点 19

什么时候使用Adapter模式 19

如果没有现成的代码 20

版本升级与兼容性 20

功能完全不同的类 20

2.6 相关的设计模式 20

2.7 本章所学知识 21

2.8 练习题 21

第2部分 交给子类 23

第3章 Template Method模式——将具体处理交给子类 23

3.1 Template Method模式 24

什么是模板 24

什么是Template Method模式 24

3.2 示例程序 24

AbstractDisplay类 25

CharDisplay类 26

StringDisplay类 27

Main类 28

3.3 Template Method模式中的登场角色 28

3.4 拓展思路的要点 29

可以使逻辑处理通用化 29

父类与子类之间的协作 29

父类与子类的一致性 29

3.5 相关的设计模式 30

3.6 延伸阅读:类的层次与抽象类 30

父类对子类的要求 30

抽象类的意义 30

父类与子类之间的协作 31

3.7 本章所学知识 31

3.8 练习题 31

第4章 Factory Method模式——将实例的生成交给子类 33

4.1 Factory Method模式 34

4.2 示例程序 34

Product类 35

Factory类 35

IDCard类 36

IDCardFactory类 36

Main类 37

4.3 Factory Method模式中的登场角色 37

4.4 拓展思路的要点 39

框架与具体加工 39

生成实例——方法的三种实现方式 39

使用模式与开发人员之间的沟通 40

4.5 相关的设计模式 40

4.6 本章所学知识 41

4.7 练习题 41

第3部分 生成实例 43

第5章 Singleton模式——只有一个实例 43

5.1 Singleton模式 44

5.2 示例程序 44

Singleton类 44

Main类 45

5.3 Singleton模式中的登场角色 46

5.4 拓展思路的要点 46

为什么必须设置限制 46

何时生成这个唯一的实例 46

5.5 相关的设计模式 47

5.6 本章所学知识 47

5.7 练习题 47

第6章 Prototype模式——通过复制生成实例 49

6.1 Prototype模式 50

6.2 示例程序 50

Product接口 51

Manager类 52

MessageBox类 52

UnderlinePen类 53

Main类 54

6.3 Prototype模式中的登场角色 55

6.4 拓展思路的要点 56

不能根据类来生成实例吗 56

类名是束缚吗 56

6.5 相关的设计模式 57

6.6 延伸阅读:clone方法和java.lang.Clonable接口 57

Java语言的clone 57

clone方法是在哪里定义的 58

需要实现Cloneable的哪些方法 58

clone方法进行的是浅复制 58

6.7 本章所学知识 58

6.8 练习题 59

第7章 Builder模式——组装复杂的实例 61

7.1 Builder模式 62

7.2 示例程序 62

Builder类 63

Director类 63

TextBuilder类 64

HTMLBuilder类 65

Main类 65

7.3 Builder模式中的登场角色 67

7.4 相关的设计模式 69

7.5 拓展思路的要点 69

谁知道什么 69

设计时能够决定的事情和不能决定的事情 70

代码的阅读方法和修改方法 70

7.6 本章所学知识 70

7.7 练习题 70

第8章 Abstract Factory模式——将关联零件组装成产品 73

8.1 Abstract Factory模式 74

8.2 示例程序 74

抽象的零件:Item类 77

抽象的零件:Link类 78

抽象的零件:Tray类 78

抽象的产品:Page类 79

抽象的工厂:Factory类 79

使用工厂将零件组装称为产品:Main类 80

具体的工厂:ListFactory类 81

具体的零件:ListLink类 82

具体的零件:ListTray类 82

具体的产品:ListPage类 83

8.3 为示例程序增加其他工厂 84

具体的工厂:TableFactory类 85

具体的零件:TableLink类 86

具体的零件:TableTray类 86

具体的产品:TablePage类 87

8.4 Abstract Factory模式中的登场角色 87

8.5 拓展思路的要点 89

易于增加具体的工厂 89

难以增加新的零件 89

8.6 相关的设计模式 89

8.7 延伸阅读:各种生成实例的方法的介绍 90

8.8 本章所学知识 91

8.9 练习题 91

第4部分 分开考虑 93

第9章 Bridge模式——将类的功能层次结构与实现层次结构分离 93

9.1 Bridge模式 94

9.2 示例程序 95

类的功能层次结构:Display类 96

类的功能层次结构:CountDisplay类 97

类的实现层次结构:DisplayImpl类 97

类的实现层次结构:StringDisplayImpl类 98

Main类 98

9.3 Bridge模式中的登场角色 99

9.4 拓展思路的要点 100

分开后更容易扩展 100

继承是强关联,委托是弱关联 100

9.5 相关的设计模式 101

9.6 本章所学知识 101

9.7 练习题 102

第10章 Strategy模式——整体地替换算法 103

10.1 Strategy模式 104

10.2 示例程序 104

Hand类 105

Strategy接口 106

WinningStrategy类 106

ProbStrategy类 107

Player类 109

Main类 109

10.3 Strategy模式中的登场角色 111

10.4 拓展思路的要点 112

为什么需要特意编写Strategy角色 112

程序运行中也可以切换策略 112

10.5 相关的设计模式 113

10.6 本章所学知识 113

10.7 练习题 113

第5部分 一致性 117

第11章 Composite模式——容器与内容的一致性 117

11.1 Composite模式 118

11.2 示例程序 118

Entry类 119

File类 120

Directory类 121

FileTreatMentException类 122

Main类 122

11.3 Composite模式中的登场角色 124

11.4 拓展思路的要点 125

多个和单个的一致性 125

Add方法应该放在哪里 126

到处都存在递归结构 126

11.5 相关的设计模式 126

11.6 本章所学知识 127

11.7 练习题 127

第12章 Decorator模式——装饰边框与被装饰物的一致性 129

12.1 Decorator模式 130

12.2 示例程序 130

Display类 131

StringDisplay类 132

Border类 132

SideBorder类 133

FullBorder类 134

Main类 135

12.3 Decorator模式中的登场角色 136

12.4 拓展思路的要点 137

接口(API)的透明性 137

在不改变被装饰物的前提下增加功能 138

可以动态地增加功能 138

只需要一些装饰物即可添加许多功能 138

java.io包与Decorator模式 138

导致增加许多很小的类 139

12.5 相关的设计模式 139

12.6 延伸阅读:继承和委托中的一致性 140

继承——父类和子类的一致性 140

委托——自己和被委托对象的一致性 140

12.7 本章所学知识 142

12.8 练习题 142

第6部分 访问数据结构 145

第13章 Visitor模式——访问数据结构并处理数据 145

13.1 Visitor模式 146

13.2 示例程序 146

Visitor类 147

Element接口 148

Entry类 148

File类 148

Directory类 149

ListVisitor类 150

FileTreatmentException类 151

Main类 151

Visitor与Element之间的相互调用 152

13.3 Visitor模式中的登场角色 154

13.4 拓展思路的要点 155

双重分发 155

为什么要弄得这么复杂 155

开闭原则——对扩展开放,对修改关闭 155

易于增加ConcreteVisitor角色 156

难以增加ConcreteElement角色 156

Visitor工作所需的条件 156

13.5 相关的设计模式 157

13.6 本章所学知识 157

13.7 练习题 157

第14章 Chain of Responsibility模式——推卸责任 161

14.1 Chain of Responsibility模式 162

14.2 示例程序 162

Trouble类 163

Support类 163

NoSupport类 164

LimitSupport类 164

OddSupport类 165

SpecialSupport类 165

Main类 166

14.3 Chain of Responsibility模式中的登场角色 167

14.4 拓展思路的要点 168

弱化了发出请求的人和处理请求的人之间的关系 168

可以动态地改变职责链 168

专注于自己的工作 169

推卸请求会导致处理延迟吗 169

14.5 相关的设计模式 169

14.6 本章所学知识 169

14.7 练习题 169

第7部分 简单化 171

第15章 Facade模式——简单窗口 171

15.1 Facade模式 172

15.2 示例程序 172

Database类 173

HtmlWriter类 174

PageMaker类 175

Main类 176

15.3 Facade模式中的登场角色 176

15.4 拓展思路的要点 177

Facade角色到底做什么工作 177

递归地使用Facade模式 178

开发人员不愿意创建Facade角色的原因——心理原因 178

15.5 相关的设计模式 178

15.6 本章所学知识 178

15.7 练习题 179

第16章 Mediator模式——只有一个仲裁者 181

16.1 Mediator模式 182

16.2 示例程序 182

Mediator接口 185

Colleague接口 186

ColleagueButton类 186

ColleagueTextField类 187

ColleagueCheckbox类 188

LoginFrame类 188

Main类 191

16.3 Mediator模式中的登场角色 191

16.4 拓展思路的要点 192

当发生分散灾难时 192

通信线路的增加 193

哪些角色可以复用 193

16.5 相关的设计模式 193

16.6 本章所学知识 193

16.7 练习题 194

第8部分 管理状态 195

第17章 Observer模式——发送状态变化通知 195

17.1 Observer模式 196

17.2 示例程序 196

Observer接口 196

NumberGenerator类 197

RandomNumberGenerator类 198

DigitObserver类 198

GraphObserver类 199

Main类 199

17.3 Observer模式中的登场角色 200

17.4 拓展思路的要点 201

这里也出现了可替换性 201

Observer的顺序 202

当Observer的行为会对Subject产生影响时 202

传递更新信息的方式 202

从“观察”变为“通知” 203

Model/View/Controller(MVC) 203

17.5 延伸阅读:java.util.Observer接口 203

17.6 相关的设计模式 204

17.7 本章所学知识 204

17.8 练习题 204

第18章 Memento模式——保存对象状态 207

18.1 Memento模式 208

18.2 示例程序 208

Memento类 209

Gamer类 210

Main类 211

18.3 Memento模式中的登场角色 215

18.4 拓展思路的要点 216

两种接口(API)和可见性 216

需要多少个Memento 217

Memento的有效期限是多久 217

划分Caretaker角色和Originator角色的意义 217

18.5 相关的设计模式 218

18.6 本章所学知识 218

18.7 练习题 218

第19章 State模式——用类表示状态 221

19.1 State模式 222

19.2 示例程序 222

金库警报系统 222

不使用State模式的伪代码 223

使用了State模式的伪代码 224

State接口 226

DayState类 226

NightState类 227

Context接口 228

SafeFrame类 228

Main类 231

19.3 State模式中的登场角色 232

19.4 拓展思路的要点 233

分而治之 233

依赖于状态的处理 233

应当是谁来管理状态迁移 233

不会自相矛盾 234

易于增加新的状态 234

实例的多面性 235

19.5 相关的设计模式 235

19.6 本章所学知识 235

19.7 练习题 236

第9部分 避免浪费 237

第20章 Flyweight模式——共享对象,避免浪费 237

20.1 Flyweight模式 238

20.2 示例程序 238

BigChar类 240

BigCharFactory类 241

BigString类 242

Main类 244

20.3 Flyweight模式中的登场角色 244

20.4 拓展思路的要点 245

对多个地方产生影响 245

Intrinsic与Extrinsic 246

不要让被共享的实例被垃圾回收器回收了 246

内存之外的其他资源 247

20.5 相关的设计模式 247

20.6 本章所学知识 247

20.7 练习题 247

第21章 Proxy模式——只在必要时生成实例 249

21.1 Proxy模式 250

21.2 示例程序 250

Printer类 251

Printable接口 252

PrinterProxy类 253

Main类 254

21.3 Proxy模式中的登场角色 254

21.4 拓展思路的要点 255

使用代理人来提升处理速度 255

有必要划分代理人和本人吗 256

代理与委托 256

透明性 256

HTTP代理 256

各种Proxy模式 257

21.5 相关的设计模式 257

21.6 本章所学知识 257

21.7 练习题 257

第10部分 用类来表现 259

第22章 Command模式——命令也是类 259

22.1 Command模式 260

22.2 示例程序 260

Command接口 261

MacroCommand类 262

DrawCommand类 263

Drawable接口 263

DrawCanvas类 264

Main类 265

22.3 Command模式中的登场角色 268

22.4 拓展思路的要点 269

命令中应该包含哪些信息 269

保存历史记录 269

适配器 269

22.5 相关的设计模式 271

22.6 本章所学知识 272

22.7 练习题 272

第23章 Interpreter模式——语法规则也是类 273

23.1 Interpreter模式 274

23.2 迷你语言 274

迷你语言的命令 274

迷你语言程序示例 275

迷你语言的语法 278

终结符表达式与非终结符表达式 279

23.3 示例程序 279

Node类 281

ProgramNode类 281

CommandListNode类 282

CommandNode类 283

RepeatCommandNode类 284

PrimitiveCommandNode类 285

Context类 285

ParseException类 286

Main类 287

23.4 Interpreter模式中的登场角色 288

23.5 拓展思路的要点 289

还有其他哪些迷你语言 289

跳过标记还是读取标记 290

23.6 相关的设计模式 290

23.7 本章所学知识以及本书的结束语 290

23.8 练习题 290

附 录 293

附录A 习题解答 294

附录B 示例程序的运行步骤 359

附录C GoF对设计模式的分类 361

附录D 设计模式Q&A 362

附录E 参考书籍 365


最后,这里为大家准备了几百本的互联网电子书,有需要的过来取吧。点击获取

本页书籍均来自网络,如有侵权,请联系我立即删除。我的邮箱:yaojianguolq@163.com

------ 全文结束------