Code Refactoring - 3.0

CODE REFACTORING - REQUIREMENTS

IDENTIFYING THE CODE THAT SMELLS

Extract Method
Turn the fragment into a method whose name explains the purpose of
the method.

Inline Method
Put the method’s body into the body of its callers and remove the method.

Inline Temp
Replace all references to that temp with the expression.

Replace Temp with Query
Extract the expression into a method. Replace all references to the temp
with the expression. The new method can then be used in other methods.

Introduce Explaining Variable
Extract the expression into a method. Replace all references to the temp
with the expression. The new method can then be used in other methods.

Split Temporary Variable
Make a separate temporary variable for each assignment.

Remove Assignments to Parameters
Use a temporary variable instead

Replace Method with Method Object
Turn the method into its own object so that all the local variables become
fields on that object. You can then decompose the method into other
methods on the same object

Substitute Algorithm
Replace the body of the method with the new algorithm

MOVING FEATURES BETWEEN OBJECTS

Move Method
Create a new method with a similar body in the class it uses most. Either
turn the old method into a simple delegation, or remove it altogether

Move Field
Create a new field in the target class, and change all its users

Extract Class
Create a new class and move the relevant fields and methods from the old
class into the new class.

Inline Class
Move all its features into another class and delete it.

Hide Delegate
Create methods on the server to hide the delegate.

Remove Middle Man
Get the client to call the delegate directly.

Introduce Foreign Method
Create a method in the client class with an instance of the server class as its
first argument.

Introduce Local Extension
Create a new class that contains these extra methods. Make this extension
class a subclass or a wrapper of the original.

Self Encapsulate Field
Create getting and setting methods for the field and use only those to access
the field.

Replace Data Value with
Object
Turn the data item into an object.

Change Value to Reference
Turn the object into a reference object.

Change Reference to Value
Turn it into a value object

Replace Array with Object
Replace the array with an object that has a field for each element.

Duplicate Observed Data
Copy the data to a domain object. Set up an observer to synchronize the two pieces
of data.

Change Unidirectional Association to
Bidirectional
Add back pointers, and change modifiers to update both sets.

Change Bidirectional Association to
Unidirectional
Drop the unneeded end of the association.

Replace Magic Number with Symbolic
Constant
Create a constant, name it after the meaning, and replace the number with it.

Encapsulate Field
Make it private and provide accessors.

Encapsulate Collection
Make it return a read-only view and provide add/remove methods

Replace Record with Data
Class
Make a dumb data object for the record.

Replace Type Code with
Class
Replace the number with a new class.

Replace Type Code with Subclasses
Replace the type code with subclasses.

Replace Type Code with State/Strategy
Replace the type code with a state object.

Replace Subclass with
Fields
Change the methods to superclass fields and eliminate the subclasses.

SIMPLIFYING CONDITIONAL
EXPRESSIONS

Decompose Conditional
Extract methods from the condition, then part, and else parts.

Consolidate Conditional Expression
Combine them into a single conditional expression and extract it.

Consolidate Duplicate Conditional
Fragments
Move it outside of the expression.

Remove Control Flag
Use a break or return instead.

Replace Nested Conditional with Guard Clauses
Use guard clauses for all the special cases.

Replace Conditional with
Polymorphism
Move each leg of the conditional to an overriding method in a subclass. Make
the original method abstract.

Introduce Null Object
Replace the null value with a null object.

Introduce Assertion
Make the assumption explicit with an assertion.

Rename Method
Change the name of the method.

Add Parameter
Add a parameter for an object that can pass on this information.

Separate Query from
Modifier
Create two methods, one for the query and one for the modification.

Parameterize Method
Create one method that uses a parameter for the different values.

Replace Parameter with Explicit
Methods
Create a separate method for each value of the parameter.

Preserve Whole Object
Send the whole object instead.

Replace Parameter with
Method
Remove the parameter and let the receiver invoke the method.

Introduce Parameter Object
Replace them with an object.

Remove Setting Method
Remove any setting method for that field.

Hide Method
Make the method private.

Replace Constructor with Factory
Method
Replace the constructor with a factory method.

Encapsulate Downcast
Move the downcast to within the method.

Replace Error Code with
Exception
Throw an exception instead.

Replace Exception with Test
Change the caller to make the test first.

Pull Up Field
Move the field to the superclass.

Pull Up Method
Move them to the superclass.

Pull Up Constructor Body
Create a superclass constructor; call this from the subclass methods.

Push Down Method
Move it to those subclasses.

Push Down Field
Move the field to those subclasses.

Extract Subclass
Create a subclass for that subset of features.

Extract Superclass
Create a superclass and move the common features to the superclass.

Extract Interface
Extract the subset into an interface.

Collapse Hierarchy
Merge them together.

Form Template Method
Get the steps into methods with the same signature, so that the original methods
become the same. Then you can pull them up.

Replace Inheritance with
Delegation
Create a field for the superclass, adjust methods to delegate to the superclass,
and remove the subclassing.

Replace Delegation with
Inheritance
Make the delegating class a subclass of the delegate.

Tease Apart Inheritance
Create two hierarchies and use delegation to invoke one from the other.

Convert Procedural Design to Objects
Turn the data records into objects, break up the behavior, and move the behavior
to the objects.

Separate Domain from
Presentation
Separate the domain logic into separate domain classes

Extract Hierarchy
Create a hierarchy of classes in which each subclass represents a special case.

CONVENTIONAL REFACTORING SOLUTION

CODE REFACTORING CYCLE
Ensure all tests
pass
Find code that
smells
Determine
Simplification
Make
Simplification
Ensure all tests
still pass

CODE REVIEW – BEST PRACTICES

Code Refactoring - 3.0

More Related Content

What's hot (17)

Similar to Code Refactoring - 3.0 (20)

Code Refactoring - 3.0

Editor's Notes