Refactoring

where to start?

01

Composing Methods

A large part of refactoring is composing methods to package code properly. Almost all the time the problems come from methods that are too long. Long methods are troublesome because they often contain lots of information, which gets buried by the complex logic that usually gets dragged in.

Extract Method Inline Method Inline Temp Introduce Explaining Variable Remove Assignments to Parameters

Replace Method with Method Object Replace Temp with Query Split Temporary Variable Substitute Algorithm

02

Moving Features Between Objects

One of the most fundamental, if not the fundamental, decision in object design is deciding where to put responsibilities. So, this set of refactorings is all about object’s responsibilities.

Extract Class Hide Delegate Inline Class Introduce Foreign Method

Introduce Local Extension Move Field Move Method Remove Middle Man

03

Organizing Data

In this chapter we’ll discuss several refactorings that make working with data easier.

Change Bidirectional Association to Unidirectional Change Reference to Value Change Unidirectional Association to Bidirectional Change Value to Reference Duplicate Observed Data Encapsulate Collection Encapsulate Field Replace Array with Object

Replace Data Value with Object Replace Magic Number with Symbolic Constant Replace Record with Data Class Replace Subclass with Fields Replace Type Code with Class Replace Type Code with State/Strategy Replace Type Code with Subclasses Self Encapsulate Field

04

Simplifying Conditional Expressions

Conditional logic has a way of getting tricky, so here are a number of refactorings you can use to simplify it.

Consolidate Conditional Expression Consolidate Duplicate Conditional Fragments Decompose Conditional Introduce Assertion

Introduce Null Object Remove Control Flag Replace Conditional with Polymorphism Replace Nested Conditional with Guard Clauses

05

Making Method Calls Simpler

Objects are all about interfaces. Coming up with interfaces that are easy to understand and use is a key skill in developing good object-oriented software. This chapter explores refactorings that make interfaces more straightforward.

Add Parameter Encapsulate Downcast Hide Method Introduce Parameter Object Parameterize Method Preserve Whole Object Remove Parameter Remove Setting Method

Rename Method Replace Constructor with Factory Method Replace Error Code with Exception Replace Exception with Test Replace Parameter with Explicit Methods Replace Parameter with Method Separate Query from Modifier

06

Dealing with Generalization

Generalization produces its own batch of refactorings, mostly dealing with moving methods around a hierarchy of inheritance.

Collapse Hierarchy Extract Interface Extract Subclass Extract Superclass Form Template Method Pull Up Constructor Body

Pull Up Field Pull Up Method Push Down Field Push Down Method Replace Delegation with Inheritance Replace Inheritance with Delegation

07

Big Refactorings

The preceding chapters present the individual “moves” of refactoring. What is missing is a sense of the whole “game.” You are refactoring to some purpose, not just to avoid making progress (at least usually you are refactoring to some purpose). What does the whole game look like?

Convert Procedural Design to Objects Extract Hierarchy Separate Domain from Presentation

Tease Apart Inheritance The Nature of the Game