Create your own shelf sign up

Together we find better books

  • Search Conteggio caratteri ISBN valido ISBN non valido Codice a barre valido Codice a barre non valido loading search

Refactoring to Patterns


Publisher: Pearson Education (US)


Language:English | Number of Pages: 400 | Format: Hardcover | In other languages: (other languages) Chi simplified , Chi traditional , German

Isbn-10: 0321213351 | Isbn-13: 9780321213358 | Publish date:  | Edition 1

Category: Computer & Technology

Do you like Refactoring to Patterns ?
Join aNobii to see if your friends read it, and discover similar books!

Sign up for free
Book Description
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 you:

Understand how to combine refactoring and patterns
Improve the design of existing code with pattern-directed refactorings
Identify areas of code in need of pattern-directed refactorings
Learn why using patterns to improve existing code is better than using patterns early in a new design
To achieve these goals, this book includes the following features:

A catalog of 27 refactorings
Examples based on real-world code, not the toy stuff
Pattern descriptions, including real-world pattern examples
A collection of smells (i.e., problems) that indicate the need for pattern-directed refactorings
Examples of different ways to implement the same pattern
Advice for when to refactor to, towards, or away from patterns
To 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 as:

Extract Method
Extract Interface
Extract Superclass
Extract Subclass
Pull Up Method
Move Method
Rename Method

Refactoring also contains references to more sophisticated refactorings, such as:

Replace Inheritance with Delegation
Replace Conditional with Polymorphism
Replace 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 about, this book includes brief pattern summaries, UML sketches of patterns, and many example implementations of patterns. To get a more detailed understanding of the patterns, I recommend that you study this book in conjunction with the patterns literature I reference.

This book uses UML 2.0 diagrams. If you don’t know UML very well, you’re in good company. I know the basics. While writing this book, I kept the third edition of Fowler’s UML Distilled Fowler, UD close by my side and referred to it often.

Sorting by