Refactoring to patterns

What Is This Book About?This book is about the marriage of refactoring—the process of improving the design of existing code—with patterns, the classic solutions to recurring design problems. Refactoring to Patterns suggests that using patterns to improve an existing design is better than using patterns early in a new design. This is true whether code is years old or minutes old. We improve designs with patterns by applying sequences of low-level design transformations, known as refactorings. What Are the Goals of This Book?This book was written to help Understand how to combine refactoring and patternsImprove the design of existing code with pattern-directed refactoringsIdentify areas of code in need of pattern-directed refactoringsLearn why using patterns to improve existing code is better than using patterns early in a new designTo achieve these goals, this book includes the following A catalog of 27 refactoringsExamples based on real-world code, not the toy stuffPattern descriptions, including real-world pattern examplesA collection of smells (i.e., problems) that indicate the need for pattern-directed refactoringsExamples of different ways to implement the same patternAdvice for when to refactor to, towards, or away from patternsTo help individuals or groups learn the 27 refactorings in the book, you'll find a suggested study sequence on the inside back cover of the book. Who Should Read This Book? This book is for object-oriented programmers engaged in or interested in improving the design of existing code. Many of these programmers use patterns and/or practice refactoring but have never implemented patterns by refactoring; others know little about refactoring and patterns and would like to learn more. This book is useful for both greenfield development, in which you are writing a new system or feature from scratch, and legacy development, in which you are mostly maintaining a legacy system. What Background Do You Need?This book assumes you are familiar with design concepts like tight coupling and loose coupling as well as object-oriented concepts like inheritance, polymorphism, encapsulation, composition, interfaces, abstract and concrete classes, abstract and static methods, and so forth. I use Java examples in this book. I find that Java tends to be easy for most object-oriented programmers to read. I've gone out of my way to not use fancy Java features, so whether you code in C++, C#, Visual Basic .NET, Python, Ruby, Smalltalk, or some other object-oriented language, you ought to be able to understand the Java code in this book. This book is closely tied to Martin Fowler's classic book Refactoring F. It contains references to low-level refactorings, such Extract MethodExtract InterfaceExtract SuperclassExtract SubclassPull Up MethodMove MethodRename Method Refactoring also contains references to more sophisticated refactorings, such Replace Inheritance with DelegationReplace Conditional with PolymorphismReplace Type Code with Subclasses To understand the pattern-directed refactorings in this book, you don't need to know every refactoring listed above. Instead, you can follow the example code that illustrates how the listed refactorings are implemented. However, if you want to get the most out of this book, I do recommend that you have Refactoring close by your side. It's an invaluable refactoring resource, as well as a useful aid for understanding this book. The patterns I write about come from the classic book Design Patterns DP, as well as from authors such as Kent Beck, Bobby Woolf, and myself. These are patterns that my colleagues and I have refactored to, towards, or away from on real-world projects. By learning the art of pattern-directed refactorings, you'll understand how to refactor to, towards, or away from patterns not mentioned in this book. You don't need expert knowledge of these patterns to read this book, though some knowledge of patterns is useful. To help you understand the patterns I've written abou