Refactoring

Introduction to Refactoring

Noun: a change made to the internal structure of software to make it
easier to understand and cheaper to modify without changing its
observable behavior

Verb: to restructure software by applying a series of refactorings
without changing its observable behavior.

Good to know, Bruno

Now, show some code please.

Extract Method
Motivation

Extract Method is one of the most common refactorings. If a method that
is too long or look at code that needs a comment to understand its
purpose.

It does take a little getting used to if you are used to seeing larger
methods. And small methods really work only when you have good names,
so you need to pay attention to naming.

The key is the semantic distance between the method name and the
method body. If extracting improves clarity, do it, even if the name is
longer than the code you have extracted.

Extract Method
Code
void printOwing(double amount)
{
printBanner();

//print details
System.out.println ("name:" + _name);
System.out.println ("amount" + amount);
}

Extract Method
Code
void printOwing(double amount) {
printBanner();

//print details
}

void printOwing(double amount) {
printBanner();
printDetails(amount);
}

void printDetails (double amount) {
}

Introduce Explaining Variable
Motivation

Expressions can become very complex and hard to read. In such
situations variables can be helpful to break down the expression into
something more manageable.

Introduce Explaining Variable is particularly valuable with conditional
logic in which it is useful to take each clause of a condition and explain
what the condition means with a well-named.

Code
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);
}

Code
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);
}

double price()
{
double basePrice = _quantity * _itemPrice;
double quantityDiscount = Math.max(0, _quantity - 500) * _itemPrice *
0.05;
double shipping = Math.min(basePrice * 0.1, 100.0);

return basePrice - quantityDiscount + shipping;
}

Replace Temp with Query
Motivation

The problem with temps is that they are temporary and local. Because
they can be seen only in the context of the method in which they are used,
temps tend to encourage longer methods, because that’s the only way you
can reach the temp. By replacing the temp with a query method, any
method in the class can get at the information. That helps a lot in coming
up with cleaner code for the class.

The straightforward cases of this refactoring are those in which temps are
assigned only to once and those in which the expression that generates
the assignment is free of side effects. Other cases are trickier but
possible.

Code
double getPrice()
{
int basePrice = _quantity * _itemPrice;
double discountFactor;

if (basePrice > 1000)
discountFactor = 0.95;
else
discountFactor = 0.98;

return basePrice * discountFactor;
}

Code
private int basePrice() {
return _quantity * _itemPrice;
}

private double discountFactor() {
if (basePrice() > 1000)
return 0.95;
else
return 0.98;
}

double getPrice() {
return basePrice() * discountFactor();
}

Substitute Algorithm
Motivation

I’ve never tried to skin a cat. I’m told there are several ways to do it. I’m
sure some are easier than others. So it is with algorithms. If you find a
clearer way to do something, you should replace the complicated way with
the clearer way. Refactoring can break down something complex into
simpler pieces, but sometimes you just reach the point at which you have
to remove the whole algorithm and replace it with something simpler. This
occurs as you learn more about the problem and realize that there’s an
easier way to do it. It also happens if you start using a library that supplies
features that duplicate your code.

Code
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";
}
return "";
}

Code
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";
}
return "";
}

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 "";
}

Extract Class
Motivation

You’ve probably heard that a class should be a crisp abstraction, handle a
few clear responsibilities, or some similar guideline. In practice, classes
grow. You add some operations here, a bit of data there. You add a
responsibility to a class feeling that it’s not worth a separate class, but as
that responsibility grows and breeds, the class becomes too complicated.
Soon your class is as crisp as a microwaved duck.

Extract Class
Code
public String getName() {
return _name;
}
public String getTelephoneNumber() {
return ("(" + _officeAreaCode + ") " + _officeNumber);
}
String getOfficeAreaCode() {
return _officeAreaCode;
}
void setOfficeAreaCode(String arg) {
_officeAreaCode = arg;
}
String getOfficeNumber() {
return _officeNumber;
}
void setOfficeNumber(String arg) {
_officeNumber = arg;
}
private String _name;
private String _officeAreaCode;
private String _officeNumber;

Extract Class
Code
private String _name;
private TelephoneNumber _officeTelephone = new TelephoneNumber();

public String getName() {
return _name;
}
public String getTelephoneNumber(){
return _officeTelephone.getTelephoneNumber();
}
TelephoneNumber getOfficeTelephone() {
return _officeTelephone;
}

Extract Class
Code
private String _number;
private String _areaCode;

public String getTelephoneNumber() {
return ("(" + _areaCode + ") " + _number);
}
String getAreaCode() {
return _areaCode;
}
void setAreaCode(String arg) {
_areaCode = arg;
}
String getNumber() {
return _number;
}
void setNumber(String arg) {
_number = arg;
}

Refactoring

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Refactoring (20)

Recently uploaded (20)

Refactoring