Refactoring

Refactoring
Source :
Refactoring
Improving the Design of Existing Code
by Martin Fowler
(with Kent Beck, John Brant, William Opdyke, and Don Roberts)
Prepared By-
Tausun Akhtary (Suptee)
Software Analyst
IPVision Canada Inc

Why Refactoring
● Improved Design
● Increased Readability.
● Less time consumption in adding/changing features.

When Refactoring is needed?
According to grandma,
If it stinks, change it.
—Grandma Beck, discussing child-rearing philosophy
We change code,
When code smells..

When Refactoring is needed?(Contd.)
● Duplicated Code
● Long Method
● Large Class
● Long Parameter List
● Divergent Change
● Parallel Inheritance Hierarchies
● Lazy Class
● Shotgun Surgery
● Feature Envy
● Data Clumps
● Primitive Obsession
● Switch Statements

When Refactoring is needed?(Contd.)
● Alternative Classes with
Different Interfaces
● Incomplete Library Class
● Data Class
● Refused Bequest
● Comments
● Speculative Generality
● Temporary Field
● Message Chains
● Middle Man
● Inappropriate Intimacy

How ?
● Composing Methods
● Moving Features Between Objects
● Simplifying Conditional Expressions
● Making Method Calls Simpler
● Organizing Data
● Dealing with Generalization
● Big Refactorings

Composing Methods
● Extract method :
○ Some lines of code that need a comment to explain what is
happening, should be extracted as a method.

Composing Methods
● Extract method :
void printOwing(double amount) {
printBanner();
//print details
System.out.println ("name:" + _name);
System.out.println ("amount" + amount);
}
void printOwing(double amount) {
printBanner();
printDetails(amount);
}
void printDetails (double amount) {
System.out.println ("name:" + _name);
System.out.println ("amount" + amount);
}

Composing Methods
● Inline method :
○ If statements in the method are self explaining, remove method
calls and keep the statements
○ Do not change polymorphic methods

Composing Methods
● Inline method :
int getRating() {
return (moreThanFiveLateDeliveries()) ? 2 : 1;
}
boolean moreThanFiveLateDeliveries() {
return _numberOfLateDeliveries > 5;
}
int getRating() {
return (_numberOfLateDeliveries > 5) ? 2 :
1;
}

Composing Methods
● Inline Temp :
○ Replace temp with expression, that can help to other
refactorings
double basePrice = anOrder.basePrice();
return (basePrice > 1000)
To
return (anOrder.basePrice() > 1000)

Composing Methods
● Replace Temp With Query:
double basePrice = _quantity * _itemPrice;
if (basePrice > 1000)
return basePrice * 0.95;
else
return basePrice * 0.98;
if (basePrice() > 1000)
return basePrice() * 0.95;
else
return basePrice() * 0.98;
...
double basePrice() {
return _quantity * _itemPrice;
}

Composing Methods
● Introduce Explaining Variable
double price() {
// price is base price - quantity discount + shipping
return _quantity * _itemPrice - Math.max(0, _quantity - 500) * _itemPrice * 0.05 + Math.min(_quantity * _itemPrice * 0.1, 100.0);
}

Composing Methods
● Introduce Explaining Variable
double price() {
final double basePrice = _quantity * _itemPrice;
final double quantityDiscount = Math.max(0, _quantity - 500) * _itemPrice * 0.05;
final double shipping = Math.min(basePrice * 0.1, 100.0);
return basePrice - quantityDiscount + shipping;
}

Composing Methods
● Split Temporary Variable
double temp = 2 * (_height + _width);
System.out.println (temp);
temp = _height * _width;
System.out.println (temp);
final double perimeter = 2 * (_height + _width);
System.out.println (perimeter);
final double area = _height * _width;
System.out.println (area);

Composing Methods
● Remove assignments to parameters
○ may be confusing for pass by reference
int discount (int inputVal, int quantity, int yearToDate) {
if (inputVal > 50) inputVal -= 2;
...
int discount (int inputVal, int quantity, int yearToDate) {
int result = inputVal;
if (inputVal > 50) result -= 2;
...
void aMethod(Object foo) {
foo.modifyInSomeWay(); // that's OK
foo = anotherObject; // trouble and despair will follow you
...

Composing Methods
● Replace Method with Method object
○ If a method has a long parameter list
//Class Account
int gamma (int inputVal, int quantity, int yearToDate) {
int importantValue1 = (inputVal * quantity) + delta();
int importantValue2 = (inputVal * yearToDate) + 100;
if ((yearToDate - importantValue1) > 100)
importantValue2 -= 20;
int importantValue3 = importantValue2 * 7;
// and so on...
return importantValue3 - 2 * importantValue1;
}

Composing Methods
● Replace Method with Method object
//class Gamma...
private final Account _account;
private int inputVal;
private int quantity;
private int yearToDate;
private int importantValue1;
Gamma (Account source, int inputValArg, int quantityArg,
int yearToDateArg) {
_account = source;
inputVal = inputValArg;
quantity = quantityArg;
yearToDate = yearToDateArg;
}

Composing Methods
● Substitute Algorithm
○ Use simpler algorithm for same task
String foundPerson(String[] people){
for (int i = 0; i < people.length; i++) {
if (people[i].equals ("Don")){
return "Don";
}
if (people[i].equals ("John")){
return "John";
}
if (people[i].equals ("Kent")){
return "Kent";
}
}
String foundPerson(String[] people){
List candidates = Arrays.asList(new String[] {"Don",
"John", "Kent"});
for (int i=0; i < people.length; i++)
if (candidates.contains(people[i]))
return people[i];
return "";
}

Moving Features Between Objects
● Move Method
○ if a method looks more
relevant to another class(like
using that class’ data more
that habituating class or does
something that is part of the
other class’ task), move that
method to the other class

● Move Field
○ A field is, or will be, used by
another class more than the
class on which it is defined,
move it to the another class.

● Extract Class
○ If a class is doing work that should be done by
two classes

● Inline Class
○ Opposite of Extract class

● Hide Delegate
○ A client is calling a delegate class of an object.
○ Create methods on the server to hide the delegate.

● Remove Middle Man
○ Opposite of hide delegate
○ If the client class has to add many features on the delegate class,
every time it will have to create a method on server class

● Introduce Foreign Method
○ A server class you are using needs an additional method, but you
can't modify the class.
○ Create a method in the client class with an instance of the server
class as its first argument.

● Introduce Foreign Method
Date newStart = new Date (previousEnd.getYear(),
previousEnd.getMonth(), previousEnd.getDate() + 1);
Add a foreign method for nextday that should be in Date class
Date newStart = nextDay(previousEnd);
private static Date nextDay(Date arg) {
// foreign method, should be on date
return new Date (arg.getYear(),arg.getMonth(), arg.getDate() + 1);
}

● Introduce Local Extension
○ If we are having several foreign methods, then should make a
local extension of the server class.

Simplifying Conditional Expressions
● Decompose Conditional
if (date.before (SUMMER_START) || date.after
(SUMMER_END)) {
charge = quantity * _winterRate + _winterServiceCharge;
}
else
charge = quantity * _summerRate;
if (notSummer(date))
charge = winterCharge(quantity);
else charge = summerCharge (quantity);
private boolean notSummer(Date date) {
return date.before (SUMMER_START) || date.after
(SUMMER_END);
}
private double summerCharge(int quantity) {
return quantity * _summerRate;
}
private double winterCharge(int quantity) {
return quantity * _winterRate + _winterServiceCharge;
}

● Consolidate Conditional Expression
double disabilityAmount() {
if (_seniority < 2) return 0;
if (_monthsDisabled > 12) return 0;
if (_isPartTime) return 0;
// compute the disability amount
...
isNotEligableForDisability() {
return (_seniority < 2 || _monthsDisabled > 12 ||
_isPartTime);
}
double disabilityAmount() {
if (isNotEligableForDisability()) return 0;
// compute the disability amount

● Consolidate Duplicate Conditional Fragments
if (self.callLogs.count) {
self.editBarButton = [[[UIBarButtonItem alloc] initWithCustomView:editButton] autorelease];
self.navigationItem.rightBarButtonItem = self.editBarButton;
self.editBarButton.enabled = YES;
}
else {
self.editBarButton.enabled = NO;
}

● Consolidate Duplicate Conditional Fragments
if (self.callLogs.count) {
self.editBarButton.enabled = YES;
}
else {
self.editBarButton.enabled = NO;
}

● Remove Control Flag(simple)
void checkSecurity(String[] people) {
boolean found = false;
if (! found) {
found = true;
}
found = true;
}
}
}
}
void checkSecurity(String[] people) {
break;
}
break;
}
}
}

● Remove Control Flag(with return value)
String found = "";
if (found.equals("")) {
found = "Don";
}
found = "John";
}
}
}
return found;
String found = "";
if (found.equals("")) {
return "Don";
}
found = "John";
}
}
}
return found;

● Replace Conditional with polymorphism
Will be covered in organizing data

● Introduce Null Object
○ Don’t ask an object’s type to do something
class Customer...
public String getName() {...}
public BillingPlan getPlan() {...}
public PaymentHistory getHistory() {...}
Customer customer = site.getCustomer();
BillingPlan plan;
if (customer == null) plan = BillingPlan.basic();
else plan = customer.getPlan();
...
String customerName;
if (customer == null) customerName = "occupant";
else customerName = customer.getName();

class NullCustomer extends Customer {
public boolean isNull() {
return true;
}
public String getName(){
return "occupant";
}
}
class Customer...
public boolean isNull() {
return false;
}
Before
String customerName;
if (customer == null) customerName = "occupant";
else customerName = customer.getName();
Now
Customer customer = site.getCustomer();
String customerName = customer.getName();

@interface RIFeed : NSObject<NSCoding>
……
Call :
id obj = [self.profileNewsFeedArray objectAtIndex:indexPath.row - 1];
if (obj == [NSNull null]) {
return kRIFeedPlaceHolderHeight;
}
else {
RIFeed *feed = [self.profileNewsFeedArray objectAtIndex:indexPath.row - 1];
return feed.feedHeight;
}

@interface RINullFeed : RIFeed<NSCoding>
- (CGFloat) feedHeight
{
return kRIFeedPlaceHolderHeight;
}
……
Call :
RIFeed *feed = [self.profileNewsFeedArray objectAtIndex:indexPath.row - 1];
return feed.feedHeight;

● Introduce Assertion
○ Only for development, helps in debugging
double getExpenseLimit() {
// should have either expense limit or a primary project
return (_expenseLimit != NULL_EXPENSE) ?
_expenseLimit:
_primaryProject.getMemberExpenseLimit();
}
double getExpenseLimit() {
Assert.isTrue (_expenseLimit != NULL_EXPENSE ||
_primaryProject != null);
return (_expenseLimit != NULL_EXPENSE) ?
_expenseLimit:
_primaryProject.getMemberExpenseLimit();
}

Making Method Calls Simpler
● Rename Method
○ A method name should reveal its purpose.
○ getTelephoneNumber() is a better name that getTNum()
● Add Parameter
○ A method needs more info.
● Remove Parameter
○ A method does not use a parameter or became the member of the
object class that was used as a parameter.
○ Do not remove parameter in polymorphic methods

● Separate Query from Modifier

● Parameterize Method
class Employee {
void tenPercentRaise () {
salary *= 1.1;
}
void fivePercentRaise () {
salary *= 1.05;
}
Can be replaced as,
void raise (double factor) {
salary *= (1 + factor);
}

● Preserve Whole Object
int low = daysTempRange().getLow();
int high = daysTempRange().getHigh();
withinPlan = plan.withinRange(low, high);
Can be replaced as,
withinPlan = plan.withinRange(daysTempRange());

● Introduce parameter Object
○ If some parameters naturally go together

● Remove Setting Method
○ I don’t want to update a field’s value without constructor/factory
method.
● Hide Method
○ If a method is not used by any other class, make it private
● Replace Constructor with Factory Method
Employee (int type) {
_type = type;
if(type == 0)
{
//Do something
}
}
static Employee create(int type) {
return new Employee(type);
if(type == 0)
{
//Do something
}
}

● Encapsulate Downcast
Object lastReading() {
return readings.lastElement();
}
We need to cast Object as Reading by its caller, so..
Reading lastReading() {
return (Reading) readings.lastElement();
}

● Replace Error Code with Exception
int withdraw(int amount) {
if (amount > _balance)
return -1;
else {
_balance -= amount;
return 0;
}
}
void withdraw(int amount) throws BalanceException {
if (amount > _balance) throw new BalanceException();
_balance -= amount;
}

Organizing Data
● Self Encapsulate Field
○ Create setter and getter for each field and use those to access
● Replace data value with object
○ turn data item into object that needs extra data or behaviour.

Organizing Data
● Change Value to Reference
○ If there are limited return values for multiple other values, we
can change value to reference.
○ one customer can have many orders, and the number of
customer is limited.

Organizing Data
class Customer {
public Customer (String name) {
_name = name;
}
public String getName() {
return _name;
}
private final String _name;
}
class Order...
public Order (String customerName) {
_customer = new Customer(customerName);
}
public void setCustomer(String customerName) {
_customer = new Customer(customerName);
}
public String getCustomerName() {
return _customer.getName();
}
private Customer _customer;

Organizing Data
some client code:
private static int numberOfOrdersFor(Collection orders, String customer) {
int result = 0;
Iterator iter = orders.iterator();
while (iter.hasNext()) {
Order each = (Order) iter.next();
if (each.getCustomerName().equals(customer)) result++;
}
return result;
}

Organizing Data
some client code:
private static int numberOfOrdersFor(Collection orders, String customer) { // if many orders have the same customer
and the number of customers is limited
int result = 0;
Iterator iter = orders.iterator();
while (iter.hasNext()) {
Order each = (Order) iter.next();
if (each.getCustomerName().equals(customer)) result++;
}
return result;

Organizing Data
private static Dictionary _instances = new Hashtable();
class Customer...
static void loadCustomers() {
new Customer ("Lemon Car Hire").store();
new Customer ("Associated Coffee Machines").store();
new Customer ("Bilston Gasworks").store();
}
private void store() {
_instances.put(this.getName(), this);
}
public static Customer getNamed (String name) {
return (Customer) _instances.get(name);
}

Organizing Data
● Change Reference to Value
○ If the reference object doing nothing much and thus awkward to
manage.

Organizing Data
● Replace Array With Object
String[] row = new String[3];
row [0] = "Liverpool";
row [1] = "15";
Replace row array with object row.

Organizing Data
● Duplicate Observed Data
○ You have domain data available only in a GUI control, and
domain methods need access.
○ Copy the data to a domain object. Set up an observer to
synchronize the two pieces of data.

Organizing Data
● Change Unidirectional Association to Bidirectional
○ You have two classes that need to use each other's features,
but there is only a one-way link.
○ Add back pointers, and change modifiers to update both sets.
class Order... //controlling methods
void addCustomer (Customer arg) {
arg.friendOrders().add(this);
_customers.add(arg);
}
void removeCustomer (Customer arg) {
arg.friendOrders().remove(this);
_customers.remove(arg);
}
class Customer...
void addOrder(Order arg) {
arg.addCustomer(this);
}
void removeOrder(Order arg) {
arg.removeCustomer(this);
}

Organizing Data
● Change Bidirectional Association to Unidirectional
○ Opposite to Previous one

Organizing Data
● Replace Magic Number With Symbolic Constant
if (textField.tag == 5555)
{ ...}
else if (textField.tag == 6666) {
…...
should be
if (textField.tag == TAG_FOR_SOMETHING)
{
}
else if (textField.tag == TAG_FOR_OTHER) {
…...

Organizing Data
● Encapsulate Field
public String _name;
Should be,
private String _name;
public String getName() {return _name;}
public void setName(String arg) {_name = arg;}

Organizing Data
● Encapsulate Collection
class Person...
public Set getCourses() {
return _courses;
}
public void setCourses(Set arg) {
_courses = arg;
}
private Set _courses;
class Person...
public Set getCourses() {
return _courses;
}
public void setCourses(Set arg) {
_courses = arg;
}
private Set _courses;
public void addCourse (Course arg) {
_courses.add(arg);
}
public void removeCourse (Course arg) {
_courses.remove(arg);
}

Organizing Data
● Replace Record with Data Class
○ You need to interface with a record structure in a traditional
programming environment.
○ Make a dumb data object for the record.

Organizing Data
● Replace Type Code with Class
○ If we have a type code that does not affect behavior
○ If no conditional statements.
class Person {
public static final int O = 0;
public static final int A = 1;
public static final int B = 2;
public static final int AB = 3;
private int _bloodGroup;
public Person (int bloodGroup) {
_bloodGroup = bloodGroup;
}
public void setBloodGroup(int arg) {
_bloodGroup = arg;
}
public int getBloodGroup() {
return _bloodGroup;
}
}

Organizing Data
● Replace Type Code with Class
class BloodGroup…
public static final BloodGroup O = new BloodGroup(0);
public static final BloodGroup A = new BloodGroup(1);
public static final BloodGroup B = new BloodGroup(2);
public static final BloodGroup AB = new BloodGroup(3);
private static final BloodGroup[] _values = {O, A, B, AB};
private final int _code;
private BloodGroup (int code ) {
_code = code;
}
private int getCode() {
return _code;
}
private static BloodGroup code(int arg) {
return _values[arg];
}
class Person ...
public static final int O = BloodGroup.O.getCode();
public static final int A = BloodGroup.A.getCode();
public static final int B = BloodGroup.B.getCode();
public static final int AB = BloodGroup.AB.getCode();
public Person (int bloodGroup) {
_bloodGroup = BloodGroup.code(bloodGroup);
}
public int getBloodGroup() {
return _bloodGroup.getCode();
}
public void setBloodGroup(int arg) {
_bloodGroup = BloodGroup.code (arg);
}

Organizing Data
● Replace Type Code with SubClasses
○ if the type code affects behavior, the best thing to do is to use
polymorphism to handle the variant behavior.
○ If the type code doesn’t change.

Organizing Data
● Replace Type Code with SubClasses
class Employee...
private int _type;
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
abstract int getType();
static Employee create(int type) {
if (type == ENGINEER) return new Engineer();
else return new Employee(type);
}
class Engineer extends Employee {
int getType() {
return Employee.ENGINEER;
}
}

Organizing Data
● Replace Type Code with State/Strategy
○ This is similar to Replace Type Code with Subclasses, but can
be used if the type code changes during the life of the object or
if another reason prevents subclassing

Organizing Data
● Replace Type Code with State/Strategy
abstract class EmployeeType {
abstract int getTypeCode();
static EmployeeType newType(int code) {
switch (code) {
case ENGINEER:
return new Engineer();
case SALESMAN:
return new Salesman();
case MANAGER:
return new Manager();
default:
throw new IllegalArgumentException
("Incorrect Employee Code");
}
}
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
}
class Engineer extends EmployeeType {
int getTypeCode () {
return Employee.ENGINEER;
}
}
………...
class Employee...
private EmployeeType _type;
int getType() {
return _type.getTypeCode();
}
void setType(int arg) {
_type = EmployeeType.newType(arg);
}

Organizing Data
● Replace Subclasses with Fields
○ If we have subclasses that vary only in methods that return
constant data, Change the methods to superclass fields and
eliminate the subclasses.

Dealing With Generalization
● Pull Up Field
● Push Down Field

● Pull Up Method
● Push Down Method

● Pull Up Constructor Body
class Manager extends Employee...
public Manager (String name, String id, int grade) {
_name = name;
_id = id;
_grade = grade;
}
class Engineer extends Employee...
public Engineer (String name, String id) {
_name = name;
_id = id;
……
}

● Pull Up Constructor Body
class Employee...
public Employee (String name, String id) {
_name = name;
_id = id;
}
class Manager extends Employee...
public Manager (String name, String id, int grade) {
super(name, id)
_grade = grade;
}
class Engineer extends Employee...
public Engineer (String name, String id) {
super(name, id);
…..
}

● Extract Subclass
○ A class has features that are used only in some instances.
○ Create a subclass for that subset of features.

● Extract Superclass
○ You have two classes with similar features.
○ Create a superclass and move the common features to the
superclass.

● Extract Interface
○ Several clients use the
same subset of a class's
interface, or two classes
have part of their
interfaces in common.
○ Extract the subset into an
interface.

● Collapse hierarchy
○ A superclass and subclass are not very different.
○ Merge them together.

● Form Template Method
○ You have two methods in subclasses that perform similar steps in
the same order, yet the steps are different.
○ Get the steps into methods with the same signature, so that the
original methods become the same. Then you can pull them up.

● Form Template Method
○ Elimination of Duplication

● Replace Inheritance With Delegation
○ A subclass uses only part of a superclasses interface or does not
want to inherit data.
○ Create a field for the superclass, adjust methods to delegate to the
superclass, and remove the subclassing.

● Replace Delegation With Inheritance
○ You're using delegation and are often writing many simple
delegations for the entire interface.
○ Make the delegating class a subclass of the delegate.

Big Refactorings
● The Nature of The Game
○ Depends on intuition
○ Takes time
○ Can be done when adding features/fixing bugs
○ Requires a degree of agreement inside the team

Big Refactorings
● Four Big Refactorings
○ Tease Apart Inheritance
○ Convert Procedural Design to Objects
○ Separate Domain from Presentation
○ Extract Hierarchy

Four Big Refactorings
● Tease Apart Inheritance
○ You have an inheritance
hierarchy that is doing
two jobs at once.
○ Create two hierarchies
and use delegation to
invoke one from the
other.

● Convert Procedural
Design to Objects
○ You have code written
in a procedural style.
○ Turn the data records
into objects, break up
the behavior, and
move the behavior to
the objects.

● Separate Domain from Presentation
○ You have GUI classes that contain domain logic.
○ Separate the domain logic into separate domain classes

● Extract Hierarchy
○ You have a class that is
doing too much work, at
least in part through many
conditional statements.
○ Create a hierarchy of
classes in which each
subclass represents a
special case.

Refactoring

More Related Content

What's hot (20)

Similar to Refactoring (20)

Recently uploaded (20)

Refactoring