Refactoring - A disciplined approach to rework for better design.

Objectives What is refactoring? History Why should I refactor? When should I refactor? How to refactor?

Definition Refactoring is a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior. It makes the software easier to understand and cheaper to modify.

Continued.. Example: compute gravitational potential energy ▫ PE grav = mass * g * height double potentialEnergy(double mass, double height) { return mass * height * 9.81; } double potentialEnergy(double mass, double height) { return mass * height * 9.81; } static final double GRAVITATIONAL_CONSTANT = 9.81; double potentialEnergy(double mass, double height) { return mass * height * GRAVITATIONAL_CONSTANT; } static final double GRAVITATIONAL_CONSTANT = 9.81; double potentialEnergy(double mass, double height) { return mass * height * GRAVITATIONAL_CONSTANT; } Magic number

Properties of Refactoring One step at a time Preserve correctness Frequent testing

Where did refactoring come from ? For a long time it was a piece of programmer lore, done with varying degrees of discipline by experienced developers, but not passed on in a coherent way. Kent Beck and Ward Cunningham were two of the first people to recognize the importance of refactoring ▫ worked with Smalltalk from the 80's onward. Ralph Johnson's work with refactoring and frameworks has also been an important contribution. Martin Fowler’s book Refactoring: Improving the Design of Existing Code is the classic reference.

Why refactor? Improves the design of software. ▫ Without refactoring, the design of the program will decay Makes software easier to understand. ▫ A good design is easy to understand Helps you find bugs. ▫ The clarification process helps find bugs Helps you program faster. ▫ Poor design slow you down

When to Refactor? As you develop ▫ Example: change a variable name to something more meaningful. Before adding functions. ▫ Sometimes the existing design does not allow you to easily add the feature. When you need to fix a bug ▫ The bug exists because the code was not clear enough for you to see the bug in the first place. When you do a code review ▫ Code reviews help spread knowledge through the development team. ▫ Works best with small review groups

Steps to refactoring Identifying bad smells of code ▫a “bad smell” = a warning sign in the code ▫e.g., time consuming code Designing solid tests ▫for the section of code under analysis. Refactoring the code ▫ based on the type of the smell Applying tests.

Bad Smells in Code Duplicated Code Long Method Large Class Long Parameter List Divergent Change Shotgun Surgery Feature Envy Data Clumps Primitive Obsession Switch Statements Parallel Interface Hierarchies Lazy Class Speculative Generality Temporary Field Message Chains Middle Man Inappropriate Intimacy Incomplete Library Class Data Class Refused Bequest

Bad smells in code Smells within classes ▫ Duplicated code ▫ Long method ▫ Large class ▫ … Smells between classes ▫ Primitive obsession ▫ Inappropriate intimacy ▫ Middle man ▫ …

Duplicated Code – (1) “The #1 bad smell” ▫ If you see the same code structure in more than one place, you can be sure that your program will be better if you find a way to unify them. ▫ What if duplicates changes Refactoring solutions ▫ Pull up a field ▫ Form a template method ▫ Substitute algorithm

Duplicated Code – (2) Pull up a field ▫ Two subclasses have the same field. ▫ Move the field to the superclass. SalesmanEngineer Employee name

Duplicated Code – (3) Form a 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.

Duplicated Code – (4) Form a template method PersonalCustomer CorporateCustomer Customer getBillableAmt() double base=unit*rate double tax=base*Site.TAX_RATE; return base+tax double base=unit*rate*0.5 double tax=base*Site.TAX_RATE*0.2; return base+tax getBaseAmt() getTaxAmt() getBaseAmt() getTaxAmt() return getBaseAmt()+getTaxAmt() getBaseAmt() getTaxAmt()

Duplicated Code – (5) Substitute algorithm ▫ Replace the body of the method with the new algorithm. duplications

Long Method – (1) The longer the method the harder it is to see what it’s doing. ▫ Poorly thought out abstractions and boundaries Refactoring solutions ▫ Extract method ▫ Replace temp with query ▫ Introduce parameter object ▫ Preserve whole object

Long Method – (2) Extract method ▫ break up into smaller private methods within the class Example private void m1(){ Statement 1;.. Statement 9; } private void m2(){ Statement 10;.. Statement 19; } private void m3(){ Statement 20;.. Statement 30; } public void methodA(){ } private void m1(){ Statement 1;.. Statement 9; } private void m2(){ Statement 10;.. Statement 19; } private void m3(){ Statement 20;.. Statement 30; } public void methodA(){ } public void methodA(){ Statement 1; Statement 2;.. Statement 30; } public void methodA(){ Statement 1; Statement 2;.. Statement 30; } m1(); m2(); m3();

Long Method – (3) Replace temp with query ▫ You are using a temporary variable to hold the result of an expression. ▫ Extract the expression into a method. if (basePrice() > 1000) { return basePrice() * 0.95; } else { return basePrice() * 0.98; } if (basePrice() > 1000) { return basePrice() * 0.95; } else { return basePrice() * 0.98; } Temp variableexpression double basePrice=basePrice(); if (basePrice > 1000) { return basePrice * 0.95; } else { return basePrice * 0.98; } double basePrice=basePrice(); if (basePrice > 1000) { return basePrice * 0.95; } else { return basePrice * 0.98; }

Long Method – (4) Introduce parameter object ▫ A group of parameters that naturally go together. ▫ Replace them with an object. amountInvoicedIn ( ) amountReceivedIn ( ) amountOverdueIn ( ) Customer start: Date end: Date DateRange Start: Date, end: Date DateRange

Long Method – (5) Preserve whole object ▫ You are getting several values from an object and passing these values as parameters in a method call. ▫ Send the whole object instead.

Large Class – (1) A class that is trying to do too much ▫ Can usually be identified by looking at how many instance variables it has. ▫ When a class has too many instance variables, duplicated code cannot be far behind. Refactoring solution ▫ Extract class ▫ Extract subclass

PhoneNumber Large Class – (2) Extract class ▫ Have one class doing work that should be done by two. ▫ Need create a new class and move the relevant fields and methods from the old class into the new class. Customer name areaCode number String: getPhoneNumber() PhoneNumber: getPhoneNumber()

LaborItem Large Class – (3) Extract subclass ▫ A class has features that are used only in some instances. ▫ Create a subclass for that subset of features. JobItem getTotalPrice() getUnitPrice() getEmployee() Do all the JobItem objects need have getEmployee function? getUnitPrice()

Primitive Obsession – (1) Over use primitive to represent data ▫ All properties of a class are primitive types  int, String, boolean, double, etc. ▫ Primitive difficult to represent data  money (which combines quantity and currency)  a date range object Refactorings ▫ Replace data value with object ▫ Replace type code with class

Primitive Obsession – (2) Replace data value with objects ▫ You have a data item that needs additional data or behavior. ▫ Turn the data item into an object. Order customer: String Customer id: String last Name:: String middleName: String firstName: String phone: PhoneNumber

Primitive Obsession – (3) Replace type code with class ▫ A class has a numeric type code that does not affect its behavior. ▫ Replace the number with a new class. Person O: int A: int B:int AB:int BloodType O: BloodType A: BloodType B: BloodType AB: BloodType bloodType:int public class Person{ …… int bloodType =BloodType.O; ……. } public class BloodType{ public static final int O 1; public static final int A 2; public static final int B 3; public static final int AB 4; }

Inappropriate Intimacy – (1) Two classes are overly entertwined ▫ Sharing of secrets between classes ▫ Leads to data coupling Refactorings ▫ Hide delegate ▫ Replace inheritance with delegation

What is that? Inappropriate Intimacy – (2) Hide delegate ▫ A client is calling a delegate class of an object. ▫ Create methods on the server to hide the delegate. Client Server Delegate taskA() public void method(){ delegate.taskA(); }

Inappropriate Intimacy – (3) ClientClass Employee Department getDepartment() getManager() public class Department{ private Employee manager; …… public Department (Employee manager){ this.manager=manager; } public string getManager(){ return manager; } ….. } manager=john. Object need to know less about other parts of the system public getManager(){ return department.getManager(); } getManager() getDepartment().getManager();

Inappropriate Intimacy – (3) 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.

Middle Man Inline Method A method's body is just as clear as its name Refactoring solution ▫ Put the method's body into the body of its callers and remove the method. int getRating() { return (moreThanFiveLateDeliveries()) ? 2 : 1; } boolean moreThanFiveLateDeliveries() { return _numberOfLateDeliveries > 5; } int getRating() { return (moreThanFiveLateDeliveries()) ? 2 : 1; } boolean moreThanFiveLateDeliveries() { return _numberOfLateDeliveries > 5; } int getRating() { return (_numberOfLateDeliveries > 5) ? 2 : 1; } int getRating() { return (_numberOfLateDeliveries > 5) ? 2 : 1; }

Why might you still not refactor your programs? You might not understand how to refactor. If the benefits are long-term, why exert the effort now? In the long term, you might not be with the project to reap the benefits! Refactoring code is an overhead activity; you're paid to write new features. Refactoring might break the existing program.

Summary Refactoring is a disciplined approach to rework for better design. Refactor when code smells. Take advantage of IDE (Eclipse/IntelliJ/ Java Studio). Check online resources for updated refactoring. Know refactoring before your interview.

References Refactoringshttp://wiki.java.net/bin/view/People/SmellsTo Refactorings

Questions?