000			06549cam a22002294a 4500
999			_c527 _d527
001			1756
005			20200702104550.0
008			060201s2006 njua b 001 0 eng
020			_a9788131713082
040			_cPK
082	0	0	_a005.13/3 _222 _bM5949
100	1		_aMetsker, Steven John.
245	1	0	_aDesign patterns in Java / _cSteven John Metsker, William C. Wake.
260			_aNew Delhi : _bPearson, _c2007
300			_axiv, 461 p. _bill. ; _c25 cm.
500			_aIncludes bibliographical references (p. 447-448) and index.
650		0	_aJava (Computer program language)
650		0	_aSoftware patterns.
700	1		_aWake, William C.,
942			_cBK
505	0		_a1 Contents 2 Preface vii 3 Chapter 1: introduction 1 4 Why patterns? 1 5 Why design patterns? 2 6 Why java? 3 7 Uml 3 8 Challenges 4 9 The organization of this book 4 10 Welcome to oozinoz! 6 11 Summary 6 12 Part i: interface _patterns 13 Chapter 2: introducing interfaces 9 14 Interfaces and abstract classes 9 15 Interfaces and obligations 11 16 Summary 13 17 Beyond ordinary interfaces 13 18 Chapter 3: adapter 15 19 Adapting to an interface 15 20 Class and object adapters 21 21 Adapting data for a jtable 25 22 Identifying adapters 31 23 Summary 32 24 Chapter 4: facade 35 25 Facades, utilities, and demos 35 26 Refactoring to facade 37 27 Summary 49 28 Chapter 5: composite 51 29 An ordinary composite 52 30 Recursive behavior in composites 52 31 Composites, trees, and cycles 55 32 Composites with cycles 60 33 Consequences of cycles 65 34 Summary 65 35 Chapter 6: bridge 67 36 An ordinary abstraction-on the way to bridge 67 37 From abstraction to bridge 70 38 Drivers as bridges 72 39 Database drivers 73 40 Summary 75 41 Part ii: responsibility _patterns 42 Chapter 7: introducing responsibility 79 43 Ordinary responsibility 80 44 Controlling responsibility with visibility 82 45 Summary 83 46 Beyond ordinary responsibility 83 47 Chapter 8: singleton 85 48 Singleton mechanics 85 49 Singletons and threads 87 50 Recognizing singleton 88 51 summary 90 52 Chapter 9: observer 91 53 A classic example-observer in guis 91 54 Model/view/controller 96 55 Maintaining an observable object 102 56 Summary 105 57 Chapter 10: mediator 107 58 A classic example-gui mediators 107 59 Mediators of relational integrity 112 60 Summary 120 61 Chapter 11: proxy 123 62 A classic example-image proxies 123 63 Image proxies reconsidered 128 64 Remote proxies 131 65 Dynamic proxies 137 66 Summary 142 67 Chapter 12: chain of responsibility 143 68 An ordinary chain of responsibility 143 69 Refactoring to chain of responsibility 145 70 Anchoring a chain 148 71 Chain of responsibility without composite 150 72 Summary 150 73 Chapter 13: flyweight 151 74 Immutability 151 75 Extracting the immutable part of a flyweight 152 76 Sharing flyweights 154 77 Summary 158 78 Part iii: construction _patterns 79 Chapter 14: introducing construction 161 80 A few construction challenges 161 81 Summary 163 82 Beyond ordinary construction 163 83 Chapter 15: builder 165 84 An ordinary builder 165 85 Building under constraints 168 86 A forgiving builder 171 87 Summary 171 88 Chapter 16: factory method 173 89 A classic example-iterators 173 90 Recognizing factory method 174 91 Taking control of which class to instantiate 175 92 Factory method in parallel hierarchies 177 93 Summary 180 94 Chapter 17: abstract factory 181 95 A classic example-gui kits 181 96 Abstract factories and factory method 188 97 Packages and abstract factories 193 98 Summary 194 99 Chapter 18: prototype 195 100 Prototypes as factories 196 101 Prototyping with clones 197 102 Summary 200 103 Chapter 19: memento 201 104 A classic example-using memento for undo 201 105 Memento durability 209 106 Persisting mementos across sessions 209 107 Summary 213 108 Part iv: operation _patterns 109 Chapter 20: introducing operations 217 110 Operations and methods 217 111 Signatures 218 112 Exceptions 219 113 Algorithms and polymorphism 220 114 Summary 222 115 Beyond ordinary operations 223 116 Chapter 21: template method 225 117 A classic example-sorting 225 118 Completing an algorithm 229 119 Template method hooks 231 120 Refactoring to template method 233 121 Summary 235 122 Chapter 22 : state 237 123 Modeling states 237 124 Refactoring to state 241 125 Making states constant 246 126 Summary 248 127 Chapter 23: strategy 249 128 Modeling strategies 249 129 Refactoring to strategy 252 130 Comparing strategy and state 256 131 Comparing strategy and template method 257 132 Summary 257 133 Chapter 24: command 259 134 A classic example-menu commands 259 135 Using command to supply a service 262 136 Command hooks 264 137 Command in relation to other patterns 266 138 Summary 267 139 Chapter 25: interpreter 269 140 An interpreter example 269 141 Interpreters, languages, and parsers 283 142 Summary 283 143 Part v: extension patterns 144 Chapter 26: introducing extensions 287 145 Principles of object-oriented design 287 146 The liskov substitution principle 288 147 The law of demeter 289 148 Removing code smells 290 149 Beyond ordinary extensions 291 150 Summary 293 151 Chapter 27: decorator 295 152 A classic example-streams and writers 295 153 Function wrappers 305 154 Decorator in relation to other patterns 314 155 Summary 315 156 Chapter 28: iterator 317 157 Ordinary iteration 317 158 Thread-safe iteration 319 159 Iterating over a composite 326 160 Summary 336 161 Chapter 29: visitor 339 162 Visitor mechanics 339 163 An ordinary visitor 341 164 Visitor cycles 348 165 Visitor risks 353 166 Summary 354 167 Part vi: appendixes 168 Appendix a: directions 355 169 Get the most out of this book 355 170 Understand the classics 356 171 Weave patterns into your code 356 172 Keep learning 357 173 Appendix b: solutions 359 174 Appendix c: oozinoz source 439 175 Acquiring and using the source 439 176 Building the oozinoz code 439 177 Testing the code with junit 440 178 Finding files yourself 440 179 Summary 441 180 Appendix d: uml at a glance 443 181 Classes 444 182 Class relationships 446 183 Interfaces 447 184 Objects 448 185 States 449 186 Glossary 451 187 Bibliography 459 188 Index