Refactoring

Refactoring
Introduction Outline
A.
B.
C.
D.
What is Refactoring?
Why do we Refactor?
How do we Refactor?
When do we Refactor?
Refactoring
Refactoring
Refactoring
A.
What is Refactoring?
Refactoring is a technique which identifies

bad code and allows promotes the restructuring of that bad code into classes and
methods that are more readable,
maintainable, and generally sparse in code.
Refactoring yields a better design of both
your classes and methods.
Refactoring
C.
How do we Refactor?
Refactoring is accomplished by
1)
2)
3)
4)
building, decomposing, and moving methods

building and decomposing classes
replacing code with patterns, and
replacing code with other techniques.
Refactoring
D. When do we Refactor?
Refactoring is done when
1)
2)
3)
4)
5)
methods or classes are too LARGE,

code, control flow, or data structures are DUPLICATED,
attributes or methods are MISPLACED,
When parameters can make code reusable
When design is poor (the code smells).
Refactoring
Benefits of Refactoring
Without refactoring, the design of the program
decays.
Refactoring helps you to develop code more
quickly.
Refactoring helps you to find bugs.
Refactoring makes software easier to
understand.
Refactoring
An example- Class Diagram
Movie
pricecode: int
children = 2
regular = 0
new_release=1
title: String
getPriceCode)_
setPriceCode()
getTitle()
Rental
Customer
name: String
rentals: vector
daysRented:int
0..*
1..1
1..1
0..*
getMovie()
getDaysRented)_
Statement()
addRental(rental)
getName():
Refactoring
An Example Sequence Diagram
Customer
Rental
Movie
statement
forallrentals
Rental: getMovie()
getPriceCode()
getDaysRented()
Refactoring
Movie
pricecode: int
children = 2
regular = 0
new_release=1
title: String
public class Movie {

public static final int CHILDRENS = 2; // type movie for children
getPriceCode)_
public static final int REGULAR = 0; // type of regular movie setPriceCode()
public static final int NEW_RELEASE = 1; // new release moviegetTitle()
private String _title; // title of the movie
private int _priceCode; // price code for movie
public Movie(String title, int priceCode) {
_title = title;
_priceCode = price Code;
Constructor
}// end constructor
public int getPriceCode() { return priceCode; }
public void setPriceCode (int agr) { _priceCode = arg; }
public String getTitle () { return _Title; }
} // end Movie
Refactoring
Rental
daysRented:int
getMovie()
getDaysRented)_
class Rental {
private Movie _movie; // movie rented
private int _daysRented; // number of days rental
public Rental(Movie movie, int daysRented) {
_movie = movie;
_daysREnted = daysRented;
Constructor
} // end Rental
public int getDaysRented() { return _daysRented; }
public Movie getMovie() { return _movie; }
}// end Rental
Refactoring
Customer
name: String
rentals: vector
Statement()
addRental(rental)
getName():
class Customer {
private String _name; // name of customer
private Vector _rentals = new Vector (); // vector of list of
rentals by the customer
Constructor
public Customer (String name) { _name = name; }

public void addRental (Rental arg)
{ _rentals.addElement(arg) }
public String getName () { return _name}
Refactoring
public String statement() {
double totalAmount = 0; // total of the statement
int frequentRenterPoints = 0; // number of frequent
rental points of a rental
Enumeration rentals = _rentals.elements(); // list of
rentals
String result = Rental Record for + getName()
+/n
while (rentals.hasMoreElements() {
double thisAmount =0;
Rental each = (Rental) rentals.nextElement();
// continued on next page
Refactoring
// determine amounts for each line // regular 2.00 for two days 1.50
extra
// new release 3.00 per day
// children 1.50 for three days
switch (each.getMovie().getPriceCode()) {
case Movie.REGULAR: // statements for a regular movie
thisAmount +=2;
if (each.getDaysRented() >2)
thisAmount +=(each.getDaysRented()-2)*1.5;
Break;
case Movie.NEW_RELEASE: // statements for a new release type
movie
thisAmount +=each.getDaysRented()*3;
Break;
case Movie_CHILDREN: // statements for a children movie
thisAmount +=1.5;
if (each.getDaysRented() >3) thisAmount
+=(each.getDaysRented()-3)*1.5;
Refactoring
// add frequent renter points

add 1 frequent renter point if NEW RELEASE rented > one day
frequentRenterPoints ++;
// add bonus for a two day new release rental
if ((each.getMovie().getPriceCode() == Movie.NEW_RELEASE) &&
each.getDaysRented() > 1) frequentRenterPoints ++;
// show figures for this rental
result +=/t + each.getMovie().getTitle*(+\t +
String.valueOf(thisAmount) + \n;
totalAmount +=thisAmount;
}
// add footer lines
result +=Amount owed is + String.valueOf(totalAmount) +
\n;
result += You earned + String.valueOf(frequentRenterPoints) +
frequent renter points;
return result;
} // end statement
// end customer
Refactoring
Refactoring Opportunities
a code cluster is setting one variable

EXTRACT it as a METHOD
returning the variable
// determine amounts for each line
case Movie.REGULAR:
thisAmount +=2;
Break;
case Movie.NEW_RELEASE:
Break;
case Movie_CHILDREN:
thisAmount +=1.5;
Break;
} // end switch
Refactoring
EXTRACT METHOD
private double amountFor(Rental each)
double thisAmount = 0.0;
case Movie.REGULAR:
thisAmount +=2;
Break;
Break;
thisAmount +=1.5;
Break;
} // end switch
return thisAmount;
} // end amountFor
page 11
Refactoring
Original Code - Customer Class
page 18

double totalAmount = 0;
int frequentRenterPoints = 0;
Enumeration rentals = _rentals.elements();
+/n
Calls the new method
thisAmount = amountFor(each);
Refactoring
a variable resides in the wrong class
MOVE the METHOD
to the class where it should reside
+/n
Should NOT be in customer class
Should be in the rental

thisAmount = amountFor(each);
Refactoring
MOVE METHOD
and rename
private double getCharge(Rental each)

double result = 0.0;
switch (each.getMovie().getPriceCode())
{
Rename
the method and result
case Movie.REGULAR:
result +=2;
if (each.getDaysRented() >2) result +=(each.getDaysRented()2)*1.5;
Break;
result +=each.getDaysRented()*3;
Break;
result +=1.5;
if (each.getDaysRented() >3) result +=(each.getDaysRented()3)*1.5;
Break;
} // end switch
return result;
Refactoring
Original Code - Customer Class
+/n
Calls the
page 19
new method
In the rental class
thisAmount = each.getCharge(each);
Refactoring
a variable is used temporarily
REPLACE TEMP with QUERY
eliminating the temp
String result = Rental Record for + getName() +/n
frequentRenterPoints += getFrequentRenterPoints();
// show figures for this rental
result +=/t + each.getMovie().getTitle*(+\t +
String.valueOf(each.getCharge()) + \n;
} // end loop
// add footer lines
result +=Amount owed is + String.valueOf(getTotalCharge) + \n;
result += You earned + String.valueOf(frequentRenterPoints) + frequent renter
points;
return result;
} // end statement
Problem temp in loop
Refactoring
EXTRACT it as a METHOD
private double getTotalFrequentRentalPoints() {
int result = 0;
result += each.getFrequentRentalPoints();
} // end loop
return result;
} // end getTotalFrequentRentalPoints
Refactoring
conditional code exist for sub-types
Use POLYMORPHISM
replacing conditional logic
switch (getMovie().getPriceCode()) {
case Movie.REGULAR:
result +=2;
if (getDaysRented() >2) result +=(getDaysRented()-2)*1.5;
Break;
result +=getDaysRented()*3;
Break;
result +=1.5;
Break;
} // end switch
return result;
} // end getCharge
Cannot make subclasses of movie

Movies can change classifications
Refactoring
object can change states in its lifetime
Use the STATE Pattern
for the variables which change values
case Movie.REGULAR:
result +=2;
Break;
Break;
result +=1.5;
Break;
} // end switch
return result;
} // end getCharge

Refactoring
State Pattern- Class Diagram
Price
Movie
1..1
1..1
getCharge()
pricecode: int
children = 2
regular = 0
new_release=1
title: String
getPriceCode)_
setPriceCode()
getTitle()
getCharge()
Regular Price
getCharge()
Childrens Price
getCharge()
New Release Price
getCharge()
Refactoring
state variables not encapsulated
SELF ENCAPSULATE FIELDS
add get and set methods
private double getCharge(int daysRented)
case Movie.REGULAR:
result +=2;
Break;
Break;
result +=1.5;
Break;
} // end switch
return result;
} // end getCharge

Refactoring
Original Code --
page 3

public static final int CHILDRENS = 2;
public static final int REGULAR = 0;
public static final int NEW_RELEASE = 1;
private String _title;
private int _priceCode;
} Sub-types
Self Encapsulate

_title = title;
}// end constructor
} // end Movie
Refactoring
public static final int CHILDRENS = 2;
public static final int REGULAR = 0;
public static final int NEW_RELEASE = 1;
private String _title;
private int _priceCode;
setPriceCode(priceCode);

_title = title;
}// end constructor
} // end Movie
Refactoring
Movie Price Sub-Classes -class Price {
abstract int getPriceCode();
} // end Price
class ChildrensPrice extends Price {
int getPriceCode () { return Movie.CHILDRENS; }
} // end ChildrensPrice
class NewReleasePrice extends Price {
int getPriceCode () { return Movie.NEW_RELEASE; }
} // end NewReleasePrice
class RegularPrice extends Price {
int getPriceCode () { return Movie.REGULAR; }
} // end RegularPrice
page 41
Refactoring
MOVE METHOD
page 45
class Price
private double getCharge(int daysRented)
case Movie.REGULAR:
result +=2;
Break;
Break;
result +=1.5;
Break;
} // end switch
return result;
} // end getCharge
}// end price
Once it is moved, we can replace

conditional with polymorphism
Refactoring
Use POLYMORPHISM
page 47
class RegularPrice
double getCharge(int daysRented)
double result = 2;
return result;
} // end getCharge
} // end regularPrice
class ChildrensPrice
double getCharge (int daysRented) {
return result
} // end getCharge
} // end ChildrensPrice
class NewRelease
double getCharge (int daysRented() { return daysRented * 3; }
Take one leg of case statement at a time.
Refactoring
Use POLYMORPHISM
page 47
class Price
abstract double getCharge (int daysRented);
Create an overiding method for the getCharge method.
Refactoring
We will look at several types of refactoring.
These include the refactoring of:
methods
generalization
classes
data
calls
conditional expressions
And some other BIG refactoring.
Refactoring
Refactoring and Composing Methods
Extract Methods from code
Inline Methods to code
Replace Temp with Query
Introduce Explaining Variables
Split Temporary Variables
Remove Assignments to Parameters
Replace Method with Method Objects
Substitute Algorithm
Refactoring
Refactoring by
Moving Features Between Objects
Move Method
Move Field
Extract Class
Inline Class
Hide Delegate
Remove Middle Man
Introduce Foreign Method
Introduce Local Extension
Refactoring
Refactoring by Organizing Data
Self Encapsulate Field
Encapsulate Field
Replace Data Value with Object
Encapsulate Collection
Change Value to Reference
Replace Record with Data Class
Change Reference to Value
Replace Type with Data Class
Replace Array with Object
Replace Type Code with Subclasss
Duplicate Observed Data

State/Strategy
Replace Type Code with
Change Unidirectional Direction to Bidirectional
Replace Subclass
Change Bidirectional Direction to Unidirectional
with Field
Replace Magic Number with Symbolic Constant
Refactoring
Refactoring by Simplifying Conditional Expressions
Decompose Conditional
Consolidate Conditional Expression
Consolidate Duplicate Conditional Fragments
Remove Control Flag
Replace nested Conditional with Guard Clauses
Replace Conditional with Polymorphism
Introduce Null Object
Introduce Assertion
Refactoring
Refactoring by Making Method Calls Simpler
Rename Method
Introduce Parameter Object
Add Parameter
Remove Setting Method
Remove Parameter
Hide Method
Separate Query from Modifier
Replace Constructor with Factory
Parameterize Method
Encapsulate Downcast
Replace Parameter with Explicit Methods

Preserve Whole Object
Replace Error Code with Exception
Replace Parameter with Method Replace Exception with Test
Refactoring
Refactoring by Dealing with Generalization
Pull Up Field
Extract Interface
Pull Up Method
Collapse Hierarchy
Pull Up Constructor Body
Form Template Method
Push Down Method
Replace Inheritance with
Push Down Field
Delegation
Extract Subclass
Replace Delegation with
Extract Superclass
Inheritance
Refactoring
Refactoring with Big Refactoring
Tease Apart Inheritance
Convert Procedural Design to Objects
Separate Domain from Presentation
Extract Hierarchy
Refactoring
Lesson One:
Self-Documenting Code and
Functional Testing
Refactoring
Process
1. Read, review and understand
2. Format and comment
3. Perform documenting refactorings
Refactoring
1. Read, review and understand
A. Read existing code
Not part of refactoring but necessary.
B. Review it for understandability
Do the variables have meaningful names?
Are their enough comments
Do the methods have meaningful names?
Refactoring
2. Format and comment
A. Format the code according to supplied standards

Format the code by some standard to aid in readability
Comment code for understanding
After reading the code add any needed comments to
increase understandability
Refactoring
4. Perform Refactorings
1. Rename Method
2. Rename Constants
3. Rename Variables
Refactoring
Rename Method
Summary:
The name of a method does not reveal its purpose
Change the name of the method.
Refactoring
Rename Method:
Motivation:
Methods should be named in a way the
communicates their intension. Think what the
comment for the method would be and turn that
comment into the name of the method.
Refactoring
Rename Method:
Customer
____________
Customer
____________
getinvcrelmt ()
getInvoiceCreditLimit()
Refactoring
Rename Method:
Mechanics:
Check if method signature is implemented by a super or sub class. If so
perform these steps for each implementation.
Declare new method with new name and copy old body into new
method.
Change body of old so it calls the new one.
Find references to old and change them to refer to new one.
Remove old method.
Compile and test.
Refactoring
Rename constants, variables methods
CONSTANTS
static final int CONTINUE = 0; // OLD OK status for game continues
static final int ENDINGSTATE=(1<< 9)-1; //OLD DONE 111 111 111
Change these two constants to make code clearer
TEST BETWEEN CHANGES.
Refactoring
if (won[black])
{
if ((black | white) == DONE) {
return OK;
BECOMES
if (won[black])
{
if ((black | white) == DONE) {
return CONTINUE;
TEST BETWEEN CHANGES.
return LOSE;
}
return STALEMATE;
return LOSE;
}
return STALEMATE;
Refactoring
VARIABLES
Image crossImage; // user image

Image notImage; // computer image
BECOMES
computerImage = getImage(getCodeBase(), "oimage.gif");
userImage = getImage(getCodeBase(), "ximage.gif");
int white; // White's current position. The computer is white.

int black; Black's current position. The user is black.
BECOMES
int userStatus; //user bitmask denotes user squares occupied OLD BLACK
int computerStatus; //computer bitmask denotes squares occupied WHITE
Refactoring
if ((white & (1 << i)) != 0) {
g.drawImage(notImage, c*xoff + 1, r*yoff + 1, this);
} else if ((black & (1 << i)) != 0) {
g.drawImage(crossImage, c*xoff + 1, r*yoff + 1, this);
BECOMES
if ((computerStatus & (1 << i)) != 0) { // if computer square taken
g.drawImage(computerImage, c*xoff + 1, r*yoff + 1, this);
} else if ((userStatus & (1 << i)) != 0) { // if user square taken
g.drawImage(userImage, c*xoff + 1, r*yoff + 1, this);
Refactoring
VARIABLES
int bestMove(int white, int black)
BECOMES
int bestMove(int computerStatus,int userStatus) { //compute best move
int pw = white | (1 << mw);
BECOMES
int pw = computerStatus | (1 << mw);
int pb = black | (1 << mb);
BECOMES
int pb = userStatus | (1 << mb);
Refactoring
white = black = 0;
BECOMES
computerStatus = userStatus = 0;
white |= 1 << (int)(Math.random() * 9);
BECOMES
computerStatus |= 1 << (int)(Math.random() * 9);
white |= 1 << best;
BECOMES
computerStatus |= 1 << best;
Refactoring
MORE VARIABLES
static int moves[] = {4,0,2,6,8,1,3,5,7};
BECOMES
static int mostStrategicMove[] = {4,0,2,6,8,1,3,5,7};
int mw = moves[i];
BECOMES
int mw = mostStrategicMove[i];
Refactoring
METHODS
boolean myMove(int m) {
boolean yourMove() {
BECOMES
boolean legalComputerMove() {
boolean legalUserMove(int m) {
if (myMove())
if (yourMove(c + r * 3))
BECOMES
if (legalComputerMove())
if (legalUserMove(c + r * 3))
Refactoring
OTHERS
mw
BECOMES
int potentialComputerMove = mostStrategicMove[i];
pb
BECOMES
int potentialUserStatus = userStatus | (1 << j);
c and r BECOMES row and col
Refactoring
A big difference
BEFORE
loop:
for (int i = 0 ; i < 9 ; i++) {
int mw = moves[i];
if (((white & (1 << mw)) == 0) && ((black & (1 << mw)) == 0)) {
int pw = white | (1 << mw);
if (won[pw]) {return mw; } // white wins, take it!
for (int mb = 0 ; mb < 9 ; mb++) {
if (((pw & (1 << mb)) == 0) && ((black & (1 << mb)) == 0)) {
int pb = black | (1 << mb);
if (won[pb]) {continue loop; } // black wins, take another
}
}
}
Refactoring
A big difference
AFTER
loop:
for (int i = 0 ; i < 9 ; i++) { // for square = 0 to < 9
if (((computerStatus & (1 << potentialComputerMove)) == 0) &&
((userStatus & (1 << potentialComputerMove)) == 0)) {
int potentialComputerStatus =
computerStatus | (1 << potentialComputerMove);
if (winningState[potentialComputerStatus]) { // computer wins
return potentialComputerMove;
} /// end if (not user taken ) && ( not computer taken )
Refactoring
A big difference
// the computer did not find a winning move
for (int j = 0 ; j < 9 ; j++) { // for square = 0 to < 9
if (((potentialComputerStatus & (1 << j)) == 0) &&
((userStatus & (1 << j)) == 0)) {
if (winningState[potentialUserStatus]) { // user wins, take another
continue loop;
} // end if won
} // end if &&
} // end for
// found a move but user would win
Refactoring
A big difference
// computer has not found a winning move
if (bestmove == -1) { // neither can win, this move will do
bestmove = potentialComputerMove;
} // end if
} // end if &&
} // end for
if (bestmove != -1) { // if no move found return the best one
return bestmove;
} // end if bestmove
Refactoring
A big difference
// there is no winning or good move take mostStrategic move
for (int i = 0 ; i < 9 ; i++) { // no great move, try first one open
int firstAvailableComputerMove = mostStrategicMove[i];
if (((computerStatus&(1<< firstAvailableComputerMove))== 0)
&& (userStatus & (1 << firstAvailableComputerMove)) == 0)) {
return firstAvailableComputerMove;
} // end if &&
} // end for
return -1; // return no more moves
} // end best move
Refactoring
Encapsulate
Refactoring
Process
1. Encapsulate ALL class variables
2. Unit test
3. Functionally test
Refactoring
1. Encapsulate ALL class variables
A.
Write get and set methods for ALL class variables

Modify ALL references to class variables to use get
and set methods.
Test methods.
Refactoring
Write getters and setters for all class variables
public int getComputerStatus () { return computerStatus; }
public Image getUserImage (){return userImage;}
public boolean getFirst () { return first; }
public Image getComputerImage () { return computerImage;}
public void setComputerStatus (int computerStatus)
{ this.computerStatus = computerStatus; }
public void setUserImage (Image userImage)
{ this.userImage = userImage;}
public void setFirst (boolean first) { this.first = first; }
public void setCommputerImage (Image computerImage)
{ this.computerImage = computerImage; }
Refactoring
Perform other encapsulation
refactorings
1. Self encapsulating field
2. Encapsulate field
3. Encapsulate collection
These are not covered in detail
Refactoring
// GETS AND SETS
ADDED TO CODE
public int getComputerStatus () { return computerStatus; }

public Image getUserImage (){return userImage;}
public boolean getFirst () { return first; }
public Image getComputerImage () { return computerImage;}
public void setComputerStatus (int computerStatus)

{ this.computerStatus = computerStatus; }
public void setUserImage (Image userImage)
{ this.userImage = userImage;}
public void setFirst (boolean first) { this.first = first; }
public void setCommputerImage (Image computerImage)
{ this.computerImage = computerImage; }
Refactoring
//METHODS that need changes in their access to variables
int bestMove(int computerStatus, int userStatus) {
has parameters making them local variables scoping? ok
boolean legalUserMove(int canidateMove) {
boolean legalComputerMove() {
int gameStatus(int computerStatus, int userStatus) {
public void paint(Graphics g) { // paint the screen
public void mouseReleased(MouseEvent e) {
Refactoring
//METHODS that need changes in their access to variables
BECOMES
setComputerStatus(0);
setUserStatus(0);
if ((userStatus | computerStatus) == ENDINGSTATE) {
BECOMES
if ((getUserStatus() | getComputerStatus()) == ENDINGSTATE) {
computerImage = getImage(getCodeBase(), "oimage.gif");
BECOMES
setComputerImage(getImage(getCodeBase(), "oimage.gif"));
Refactoring
// domain functionality and GUI
switch (gameStatus()) { // determine status
case WIN:
case LOSE:
case STALEMATE:
play(getCodeBase(), "audio/return.au");
if (first) { // reset first
computerStatus |= 1 << (int)(Math.random() * 9);
}// end if
first = !first;
repaint(); // GUI controlling when to display
// RED LINED code NEEDS TO BE A METHOD TO TEST
Refactoring
Make it a METHOD
public void resetFirst() {
if (getComputerFirst()) { // reset who is first
setComputerStatus ( 1 << (int)(Math.random() * 9));
}// end if
setComputerFirst (!getComputerFirst());
} // end resetStatus
Refactoring
Call the METHOD Now this is all GUI code
switch (gameStatus()) { // determine status
case WIN:
case LOSE:
case STALEMATE:
resetStatus();
repaint();
return;
} // end switch
Refactoring
Constants and Variables
Refactoring
Process
1. Review scope of all constants
2. Review scope of all variables
3. Adjust any gets/sets due to reviews
4. Apply refactorings
Refactoring
1. Review the scope of all constants
2. Review the scope of all variables
3. Adjust code to limit scope
A.
Review all the constants and variables to make sure

they are not MORE global in scope than necessary.
Downcast any that are too broad in scope.
Adjust gets and sets to adapt to new or modified
scope.
Refactoring
2
1
3
Investigate variables, parameters, and methods to see if they can be local
or need to be uplifted to later evaluate their partitioning into classes.
Refactoring
private static int mostStrategicMove[] = {4,0,2,6,8,1,3,5,7};
// square order of importance
BECOMES
int mostStrategicMove[] = {4,0,2,6,8,1,3,5,7};// square order of importanc

// in the method bestMove
Refactoring
4. Apply Refactorings
Replace Magic Number with Symbolic
Constant
Introduce Explaining Variable
Split Temporary Variable
Separate Query from Modifier ****
Replace Array with Object *****
Not all of these are covered in detail.
Refactoring
Replace Magic Number with Symbolic Constant

Summary:
You have a literal number with a particular meaning
Create a constant, name it after the meaning, and

replace the number with it.
Refactoring
Replace Magic Number with
Symbolic Constant:
Motivation:
Magic numbers are numbers with special values that
usually are not obvious.
Add a constant to store the values of these magic

numbers.
Refactoring
Replace Magic Number with
Symbolic Constant:
Example:
double potentialEnergy (double mass, double height) {
return mass * 9.81 * height;
}// end potential Energy
Should be
double potentialEnergy (double mass, double height {
return mass * GRAVITATIONAL_CONSTANT * height;
}// end potentialEnergy
static Final double GRAVITATIONAL_CONSTANT * 9.81;
Refactoring
Replace Magic Number with Symbolic
Constant:
Mechanics:
declare a constant and set to magic number
find occurrences of magic number
if magic matches constant usage use constant
when all magic numbers changed
compile and test.
Refactoring
Replace Magic Number with Symbolic Constant:
static final int ENDINGSTATE = (1 << 9) - 1;
BECOMES
static final int NINE_SHIFTING_BITS = 9;
static final int ENDINGSTATE = (1 << NINE_SHIFTING_BITS) - 1;
for (int i = 0 ; i < 9 ; i++) { // for square = 0 to < 9
BECOMES
static final int firstCell = 0; // first cell at row 1 col 1
static final int lastCell = 8; // last cell at row 3, col 3
for (int i = firstCell ; i <= lastCell ; i++) { \
Refactoring
int bestmove = -1;
if (bestmove == -1) {
if (bestmove != -1) {
return -1; // return no more moves
BECOMES
static final int bestMoveNotFound = -1; //indicating best move not
found
int bestmove = bestmoveNotFound;
if (bestmove == bestMoveNotFound) {
if (bestmove != bestMoveNotFound) {
return bestMoveNotFound; // return no more moves
Refactoring
for (int row = 0 ; row < 3 ; row++) {
for (int col = 0 ; col < 3 ; col++, i++) {
int col = (x * 3) / d.width;// determine col
int row = (y * 3) / d.height; // determine the row
BECOMES
static final int NUMBER_OF_COLUMNS = 3;
static final int NUMBER_OF_ROWS = 3;
for (int row = 0 ; row < NUMBER_OF_ROWS ; row++) {
for (int col = 0 ; col < NUMBER_OF_COLUMNS ; col++, i++) {
int col = (x * NUMBER_OF_COLUMNS) / d.width;// determine col
int row = (y * NUMBER_OF_ROWS) / d.height; // determine the row
Refactoring
4. Introduce Explaining Variable

Summary:
You have a complicated expression.
Put the result of the expression in a temp with a name
that explains the purpose.
Refactoring
4. Introduce Explaining Variable:
Motivation:
Complex code that requires many lines of code but
could more easily be explained with some variable
name that helps to explain the code semantics.
Refactoring
Example:
If ( (platform.toUpperCase().indexOf(MAC) > -1) &&

(browser.toUpperCase().indexOf(IE) > -1) &&
wasInitialized () && resize >0)
{ .. other code ..}
goes to
final boolean isMacOs
> -1;
= platform.toUpperCase().indexOf(MAC)
final boolean isIEBrowser

-1;
= platform.toUpperCase().indexOf(IE) >
final boolean wasResized
= resize >0;
Refactoring
Mechanics:
declare a final temp variable
set it to the result portion of the expression
compile and test
Refactoring
5. Split Temporary Variables

Summary:
You have one temp assigned to more than once and it
is not a loop variable.
Make a new temp for each assignment
Refactoring
5. Split Temporary Variables:
Motivation:
Looping variables (control variables of a loop) or
accumulator variables (summing variables) may have
the need for assignments more than once. Other
variables should not be assigned to more than once.
Investigation of greater than one assignments to the
same variable may yield variables that are actually
used for different semantics.
Refactoring
Example:
double getDistanceTravelled (int time) {

double result;
double acc = _primaryForce / _mass;
force
// initial value of acceleration of first
int primaryTime = Math.min(time, _delay);

result = 0.5 * acc * primaryTime * primaryTime;
int secondaryTime = time - _delay;
if (secondaryTime > 0) {
double primaryVel = acc * _delay;
acc = (_primaryForce * _secondaryForce) / _mass; // final value of acceleration
result += primaryVel * secondaryTime + 0.5 *acc * secondaryTime *
secondaryTime;
} // end if
return result;
Refactoring
Example:
double getDistanceTravelled (int time) {

double result;
double primaryacc = _primaryForce / _mass; // initial value of acceleration of first force
int primaryTime = Math.min(time, _delay);
result = 0.5 * primaryacc * primaryTime * primaryTime;
int secondaryTime = time - _delay;
if (secondaryTime > 0) {
double primaryVel = acc * _delay;
double acc = (_primaryForce * _secondaryForce) / _mass; // final value of acceleration
result += primaryVel * secondaryTime + 0.5 *acc * secondaryTime * secondaryTime;
} // end if
return result;
} // end getDistanceTravelled
CAN YOU THINK OF OTHER REFACTORING?
Refactoring
Mechanics:
find the variables assigned to more than once
change the name for each different assignments
change references
compile and test
Refactoring
3. Replace Temp with Query

Summary:
You are using a temporary variable to hold the result
of an expression.
Extract the expression into a method Replace all
references to the temp with the expression.
Refactoring
3. Replace Temp with Query:
Motivation:
Methods with many temps tend to be long.
Replacing the temp variable with a query method
makes the code cleaner for further refactoring.
Refactoring
double getPrice(){
int basePrice = _quanity * itemPrice;
double discountFactor;
if (basePrice > 1000) discountFactor = 0.95
else discountFactor = 0.98;
return basePrice *discountFactor;
}// end getPrice
Example:
Refactoring
Example:
double getPrice(){
int basePrice = _quanity * itemPrice;
double discountFactor;
if (basePrice() > 1000) discountFactor = 0.95
return basePrice() *discountFactor;
}// end getPrice
private int basePrice () { return quanity * itemPrice; }
Refactoring
Example:
double getPrice(){
double discountFactor = discountFactor();
if (basePrice() > 1000) discountFactor = 0.95
}// end getPrice
private double discountFactor () {
if (basePrice() > 1000) return 0.95;
else return 0.98;
} // end discountFactor
Extract Method
Refactoring
Example:
double getPrice(){
double discountFactor = discountFactor();
}// end getPrice
private double discountFactor () {
Can I do more?
if (basePrice() > 1000) return 0.95;

else return 0.98;
} // end discountFactor
private int basePrice () { return quanity * itemPrice; }
Refactoring
Mechanics:
declare the temp as final to check references
compile to test
extract the right hand side as a method body
if a loop take entire loop
name and construct the method
replace the temp with the call
Refactoring
int best = bestMove(computerStatus, userStatus);
setComputerStatus (computerStatus | 1 << best);
BECOMES
setComputerStatus
(computerStatus | 1 << bestMove(computerStatus, userStatus));
Refactoring
Methods
Refactoring
Learning objective
good object-oriented methods.
Primary refactoring used to produce
good methods is Extract Method,
but others are covered.
Refactoring
Good method is defined as a
method with an acceptable level of
cohesion [Kwang99,Smith04]
Refactoring
Good method is further defined
as a method
acceptably cohesive
less than 20 lines in length
accomplishes one functionality
testable with one unit test method
Refactoring
Kang [KAN99, SMI04] defines levels
of cohesion which are ranked from
the best level to the worst.
Functional, sequential and
communicational cohesion in
methods is an acceptable level.
Refactoring
Functional cohesion deals with the
ability of a method to produce only
one output (i.e., to change the state of
only one member variable) and is
considered the best level of cohesion.
Refactoring
In sequential cohesion, more than
one variable is modified; however, all
modifications result in the change to
only one member variable. The
outputs of one or more modifications
are the inputs to the modification of
the member variable.
Refactoring
In communicational cohesion,
multiple outputs are dependent on a
common input but are not derived in
a loop or selection statement. Not as
good as functional or sequential,
refactor if possible.
Refactoring
Method sizes may be very small as a
natural consequence of good objectoriented design [Lieberherr89]. Studies
have shown that larger methods result in a
reduction in understandability, reuse, and
maintainability. [Hudli94, Lorenz94,
McCabe94, Tegaden92].
Refactoring
Refactorings used
Extract Method
Inline Method
Refactoring
1. Extract Method
Summary: - most key refactoring method
You have a cluster of code which can be grouped into
a method to simplify the code.
Turn the cluster in to a method with a name that
explains the function of the method.
Refactoring
1. Extract Method:
Motivation:
Method is too long, needs comments to understand.
Need very small methods returning one value.
Method names are allowed to be longer than the code
itself.
Refactoring
1. Extract Method:
Example: no local variables
void printOwing() {
Enumeration e = _orders.elements();
double outstanding = 0.0;
// print banner
System.our.println (*************);
System.our.println (Customer Owes)
// caculate outstanding
while (e.hasMoreElements()) {
Order each = (Order) e.nextElement();
outstanding += each.getAmount();
// print details
System.out.println (name: + _name);
System.out.println (amount + outstanding);
Refactoring
1. Extract Method:
Example: no local variables
void printOwing() {
printBanner();
// cacluate outstanding
// print details
Void printBanner() {
} // end printBanner
Refactoring
1. Extract Method:
Example: locals only referenced
void printOwing() {
printBanner()
// print details
Void printBanner() {
} // end printBanner
Refactoring
1. Extract Method:
Example: locals only referenced

pass in needed data as parameters
void printOwing() {
printBanner()
printDetails (outstanding);
.
Void printDetails (double outstanding) {

Refactoring
1. Extract Method:
Example: one local updated
void printOwing() {
printBanner()
Void printDetails (double outstanding) {
Refactoring
1. Extract Method:
Example: one local updated

return updated local
void printOwing() {
printBanner()
double outstanding = getOutstanding();
Double getOutstanding() {
} // end while
return outstanding;
} // end getOutstanding
Refactoring
1. Extract Method:
Mechanics
locate clusters of actual code

copy to a new method
if local variables needed define parameters
if local variable (one) updated make return type
build call
if local variable updated (more than one)
make multiple methods or split variables
build calls
Refactoring
2. Inline Method
Summary:
You have a method body that is just as clear as the
name of the method
Turn the method into inline code rather than a
method.
Refactoring
2. Inline Method:
Motivation:
The body is just as clear as a method name and there
exist needless indirection.
Refactoring
2. Inline Method:
Example:
int getRating ()}

return (moreThanFiveLateDeliveries () ? 2:1;
}// end getRating
boolean moreThanFiveLateDeliveries() {
return _numberofLateDeliveries > 5;
} // end moreThanFiveLateDeliveries
Refactoring
2. Inline Method:
Example:
int getRating ()}

return _numberofLateDeliveries > 5 ? 2:1;
} // end getRating
Refactoring
2. Inline Method:
Mechanics:
find calls to the method

replace with inline code
test
remove method definition
Refactoring
????
????
????
????
????
????
????
????
????
init()
destroy()
legalComputerMove()
legalUserMove () *acceptably cohesive
*less than 20 lines
gameStatus ()
*accomplishes one functionality
resetFirst()
*testable with one unit test
paint ()
* Indicates that it meets criteria
mouseReleased()
bestMove() - more than 20 lines
Refactoring
**** init()
public void init() { // initialize applet, load images, add listener
setComputerImage(getImage(getCodeBase(), "oimage.gif"));
setUserImage(getImage(getCodeBase(), "ximage.gif"));
addMouseListener(this);
} // end init
*Cohesive acceptable - modifies two class variables indirectly
*Size: acceptable
*One functionality: TWO set up images and add listener
what if we wanted to implement a phone interface.
*One unit test: neet two tests one for images and one for listenert
Refactoring
**** destroy()
public void destroy() { // destroy listener needed for closing
removeMouseListener(this);
} // end destroy
*Cohesive modifies no class variables - acceptable
*Size acceptable
*One function only one acceptable
*One unit test only one acceptable
Refactoring
**** init()
**** destroy()
???? legalComputerMove()
???? legalUserMove ()
*acceptably cohesive
???? gameStatus ()
*less than 20 lines
???? resetFirst()
???? paint ()
???? mouseReleased()
???? bestMove() - more than 20 lines
Refactoring
boolean legalUserMove(int computerStatus, int userStatus, int canidateMo

{
if ((canidateMove < 0) || (canidateMove > 8)) { return false; } // end if
if (((userStatus | computerStatus) & (1 << canidateMove)) != 0)
{ return false;} // end if
setUserStatus (userStatus | 1 << canidateMove);
return true;
} // end legalUserMove
*Cohesive modifies userStatus indirectly - acceptable
*Size acceptable
*Only One function NO Test legal AND sets user status
*Testable two types of tests for two function
LOOK at where this method is callled to see if we can separate.
Refactoring
boolean legalUserMove(int computerStatus, int userStatus, int
canidateMove) {
if ((canidateMove < 0) || (canidateMove > 8)) { return false; } // end if
if (((userStatus | computerStatus) & (1 << canidateMove)) != 0)
{return false;} // end if
return true;
if (legalUserMove(getComputerStatus(), getUserStatus(), col + row * 3)) {

repaint();
.
Refactoring
**** legalUserMove ()
boolean legalUserMove(int computerStatus, int userStatus, int canidateMo

{ // user move return true if legal move
if ((canidateMove < 0) || (canidateMove > 8)) { return false;} // end if
if (((userStatus | computerStatus) & (1 << canidateMove)) != 0) {
return false;
} // end if
return true;
int canidateMove = col + row * 3;

if (legalUserMove(getComputerStatus(), getUserStatus(), canidateMove)
Refactoring
???? legalComputerMove()
boolean legalComputerMove(int computerStatus, int userStatus) {

if ((userStatus | computerStatus) == ENDINGSTATE) {return false;} //end
setComputerStatus(computerStatus|1<<bestMove(computerStatus,userStat
return true;
} // end legalComputerMove
Cohesive = modifies computerStatus indirectly -- acceptable
Size acceptable
One function NO it test if legal AND sets computer status
Testing - two types of tests one for the legality and one for set
Again LOOK at where this method is called to see if we can separate
Refactoring
**** legalComputerMove()
if ((userStatus | computerStatus) == ENDINGSTATE) {return false;} //
setComputerStatus
(computerStatus | 1 << bestMove(computerStatus, userStatus));
return true;
if (legalComputerMove(getComputerStatus(), getUserStatus())) {
repaint();
Refactoring
if ((userStatus|computerStatus)==ENDINGSTATE) {return false; } // end
return true;
setComputerStatus
(computerStatus | 1 << bestMove(getComputerStatus(),
getUserStatus()));
Refactoring
**** init()
**** destroy()
???? gameStatus ()
*less than 20 lines
???? resetFirst()
???? paint ()
Refactoring
****
gameStatus ()
int gameStatus(int computerStatus, int userStatus ) {

if (winningState[computerStatus]) { return WIN;} // end if
if (winningState[userStatus]) { return LOSE;
} // end if
if ((userStatus | computerStatus) == ENDINGSTATE) {
return STALEMATE;
} // end if
return CONTINUE;
Cohesive = no modifications -- acceptable
} // end gameStatus
Size acceptable
One function acceptable
Testing - one test acceptable (4 test needed.
Refactoring
???? resetFirst()
public boolean resetFirst (boolean computerFirst) {
if (computerFirst) { // reset who is first
}// end if
return !computerFirst;
Cohesive = modifies one indirectly -- acceptable
Size acceptable
One function NO resets first AND sets computer status
Testing - two types of tests one for reset and one for the set
LOOK at where this method is called to see if we can separate
Refactoring
**?? resetFirst()
public boolean resetFirst (boolean computerFirst) {
if (computerFirst) { // reset who is first
}// end if
return !computerFirst;
\
setComputerFirst (resetFirst(getComputerFirst()));
Refactoring
**** resetFirst()
if (computerFirst) {
}// end if
setComputerFirst (!computerFirst);
It makes more sense to take move the code back into the
calling method and look (our case) or relook (if already
evaluated) at the calling method for characteristics of
Refactoring
*less than 20 lines
**** init()
**** destroy()
**** gameStatus ()
**** resetFirst()
???? paint ()
Refactoring
???? paint ()
Dimension d = getSize();
g.setColor(Color.black);
int xoff = d.width / NUMBER_OF_ROWS;
int yoff = d.height / NUMBER_OF_COLUMNS;
g.drawLine(xoff, 0, xoff, d.height); // draw first horiz line
g.drawLine(2*xoff, 0, 2*xoff, d.height); // draw second line
g.drawLine(0, yoff, d.width, yoff); // draw first verticle line
g.drawLine(0, 2*yoff, d.width, 2*yoff); // draw second line
Refactoring
???? paint () **continued
int i = 0;
for (int row = 0 ; row < NUMBER_OF_ROWS ; row++) {draw images
if ((getComputerStatus() & (1 << i)) != 0) { // if square take
g.drawImage(getComputerImage(), col*xoff + 1,row*yoff + 1, thi
} else if ((getUserStatus() & (1 << i)) != 0) { // if user square taken
g.drawImage(getUserImage(), col*xoff + 1, row*yoff + 1, th
} // end if
}// end for
} // end for
} // end paint
Refactoring
*??* paint () **continued
Cohesive sets no class variables acceptable
Size somewhat long
Functionality - two exist
1) draw the grid
2) draw the images
Testing would need two tests for each each
function except both are gui
so these are functional tests
SO we will separate the functions
Refactoring
THE NEW methods
public void drawGrid(Graphics g, Dimension d, int xoff, int yoff){
g.drawLine(xoff, 0, xoff, d.height); // draw first horizontal line
g.drawLine(2*xoff, 0, 2*xoff, d.height); // draw second horizontal line
g.drawLine(0, yoff, d.width, yoff); // draw first verticle line
g.drawLine(0, 2*yoff, d.width, 2*yoff); // draw second verticle line
} // end drawGrid
Refactoring
THE NEW methods
public void drawImages(Graphics g, Dimension d, int xoff, int yoff){

int i = 0;
for (int row = 0 ; row < NUMBER_OF_ROWS ; row++) { // draw computer and user images
if ((getComputerStatus() & (1 << i)) != 0) { // if computer bitmask square taken
g.drawImage(getComputerImage(), col*xoff + 1, row*yoff + 1, this);
} else if ((getUserStatus() & (1 << i)) != 0) { // if user bitmask square taken
g.drawImage(getUserImage(), col*xoff + 1, row*yoff + 1, this);
} // end if
}// end for
} // end for
} // end draw Images
Refactoring
**** paint () THE NEW paint
g.setColor(Color.black);
int xoff = d.width / NUMBER_OF_ROWS;
int yoff = d.height / NUMBER_OF_COLUMNS;
drawGrid(g, d, xoff, yoff);
drawImages (g, d, xoff, yoff);
}// end paint
Refactoring
*less than 20 lines
**** init()
**** destroy()
**** gameStatus ()
**** resetFirst()
**** paint ()
Refactoring
public void mouseReleased(MouseEvent e) { // user clicked applet
int x = e.getX(); // get mouse x location
int y = e.getY(); // get mouse y location
Many functions are included in this method and we will extract this
functionality in methods
Refactoring
// this code checks if the game is over on the previous move
switch (gameStatus(getComputerStatus(), getUserStatus())) {
case WIN:
case LOSE:
case STALEMATE:
setUserStatus(0);
}// end if
repaint();
return;
Refactoring
// find out where the click occurred
int col = (x * NUMBER_OF_COLUMNS) / d.width;
int row = (y * NUMBER_OF_ROWS) / d.height;
Refactoring
// determine if user move causes a win or stalemate
if (legalUserMove(getComputerStatus(),getUserStatus(),col+row*3)) {
repaint();
case WIN:
System.out.println ("I win");
break;
case LOSE:
System.out.println ("You win");
break;
case STALEMATE:
System.out.println ("No Winner");
break;
Refactoring
// find a legal computer move and see if it wins or stales
default:
repaint();
case WIN:
System.out.println ("I win this move");
break;
case LOSE:
System.out.println ("You win this move");
break;
case STALEMATE:
System.out.println ("No Winner this move");
break;
default:
Refactoring
Cohesive sets computerStatus, computerFirst, userStatus
Size somewhat long
Functionality - many functions some may be reusable
Testing would need many tests
SO we will separate the functions
Refactoring
???? gameOver()
public boolean gameOver(int status) {
// check and reset if a WIN, LOSE, or STALEMATE after computer move
switch (status) {
case WIN:
case LOSE:
case STALEMATE:
setUserStatus(0);
if (computerFirst) { setComputerStatus ( 1 << (int)(Math.random() * 9));
}// end if
*Cohesive NO all sets here
repaint();
*Size - acceptables
return true;
default:
return false;
*One functionality - no many
} // end switch
*Testable no many
} // end gameOver
Refactoring
???? resetGame()
public void resetGame () {
setUserStatus(0);
}// end if
} // end resetGame
*Cohesive NO all sets here
*Size - acceptable
*One functionality - no many
*Testable yes only one not a set
Refactoring
**** playComputerIffirst()
public void playComputerIfFirst ( ) {
if (getComputerFirst()) {
}// end if
} // end playComputerIfFirst
*Cohesive only indirectly sets one class variable
*Size - acceptable
*One functionality - yes
*Testable yes
Refactoring
**** resetGame()
public void resetGame () {
setUserStatus(0);
playComputerifFirst ( );
setComputerFirst (!getComputerFirst());
} // end resetGame
*Cohesive acceptable ONLY sets
*Size - acceptable
*One functionality - only sets
*Testable yes sets
Refactoring
???? mouseReleased() new version 2
int col = (x * NUMBER_OF_COLUMNS) / d.width; // determine col
int row = (y * NUMBER_OF_ROWS) / d.height; // determine row
if (gameOver (gameStatus(getComputerStatus(), getUserStatus()))) {
resetGame();
repaint();
return;
} // end if
Refactoring
mouseReleased () VERSION 2 CONTINUED
// determine if user move causes a win, loose or stalemate and post it
if (legalUserMove(getComputerStatus(),getUserStatus(),col+row*3)) {
repaint();
case WIN:
System.out.println ("I win");
break;
case LOSE:
System.out.println ("You win");
break;
case STALEMATE:
System.out.println ("No Winner");
break;
Refactoring
// find a legal computer move and see if it wins or stales // VERSION 2
default:
repaint();
case WIN:
System.out.println ("I win this move");
break;
case LOSE:
System.out.println ("You win this move");
break;
case STALEMATE:
System.out.println ("No Winner this move");
break;
default:
Refactoring
???? postGameStatus()
public void postGameStatus (int status) {
switch (status) {
case WIN:
System.out.println ("I win #1");
break;
case LOSE:
System.out.println ("You win #1");
break;
case STALEMATE:
System.out.println ("No Winner #1");
*Cohesive no modifies acceptable
break;
*Size - acceptable
default:
*One functionality - yes acceptable
} // end switch
*Testable yes one type (3 tests)
} // end checkGameStatus
Refactoring
???? VERSION 3 of mouseReleased()
int col = (x * NUMBER_OF_COLUMNS) / d.width; / determine col
resetGame();
repaint();
return;
Refactoring
???? REMAINDER OF mouseReleased() VERSION 3

if (legalUserMove(getComputerStatus(), getUserStatus(), canidateMove)) {
repaint();
int status = gameStatus(getComputerStatus(), getUserStatus());
if (!(status == CONTINUE)) {
postGameStatus (status); }
else {
setComputerStatus(computerStatus|1<<bestMove(getComputerStatus(),getUserSt
repaint();
postGameStatus(gameStatus(getComputerStatus(), getUserStatus()));
} else { play(getCodeBase(), "audio/beep.au"); } // end else
} // end else
} else { // not legal user move
play(getCodeBase(), "audio/beep.au");
}// end else
Refactoring
???? mouseReleased() VERSION 3
*Cohesive sets two class variables indirectly ?

*Size still somewhat large
*One functionality - no several functions
tries to moveUser and moveComputer
*Testable no several types per function
Refactoring
???? mouseReleased() VERSION 4
int col = (x * NUMBER_OF_COLUMNS) / d.width; get col
resetGame();
repaint();
return;
} // end if
Refactoring
???? mouseReleased() VERSION 4 CONTINUED
if (legalUserMove(getComputerStatus(), getUserStatus(), canidateMove))
repaint();
int status = gameStatus(getComputerStatus(), getUserStatus());
if (status == CONTINUE) {
repaint();
moveComputer();
} else { play(getCodeBase(), "audio/beep.au"); } // end else
} else { postGameStatus (status); } // end else
} else { play(getCodeBase(), "audio/beep.au"); }// end else // not legal
Still not good but best we can do
Refactoring
*less than 20 lines
**** init()
**** destroy()
**** gameStatus ()
**** resetFirst()
**** paint ()
**?? mouseReleased()
???? bestMove()
Refactoring
???? bestMove ()
int mostStrategicMove[] = {4,0,2,6,8,1,3,5,7};
int bestmove = bestMoveNotFound;
loop:
for (int i = firstCell ; i <= lastCell ; i++) {
Refactoring
???? bestMove () CONTINUED
for (int j = firstCell ; j <= lastCell ; j++) { // for square = 0 to < 9

((userStatus & (1 << j)) == 0)) {
if (winningState[potentialUserStatus]) { // user wins, take anothe
continue loop;
} // end if won
} // end if &&
} // end for
if (bestmove == bestMoveNotFound) { // neither wins, this move will
do
} // end if
} // end if &&
Refactoring
???? bestMove () CONTINUED
*Cohesive sets no class variables
*Size somewhat large
*Testable one type (several tests)
Refactoring
???? userWins ()
public boolean userWins (int potentialComputerStatus) {
for (int j = firstCell ; j <= lastCell ; j++) { // for square = 0 to < 9
((userStatus & (1 << j)) == 0)) {
if (winningState[potentialUserStatus]) {
// user wins, take anothe
return true;
} // end if won
*Cohesive no changes to class var
} // end if &&
*somewhat long
} // end for
*one function yes one
return false;
*testable - yes one type of test
} // end checkIfUserWon
Refactoring
???? bestMove ()
VERSION 2

int mostStrategicMove[] = {4,0,2,6,8,1,3,5,7};
int bestmove = bestMoveNotFound;
loop:
Refactoring
???? bestMove ()
VERSION 2 CONTINUED
for (int i = firstCell ; i <= lastCell ; i++) {
if (userWins (potentialComputerStatus)) { continue loop;}
if (bestmove == bestMoveNotFound) { // neither can win
} // end if
} // end if &&
Refactoring
???? bestMove ()
VERSION 2 CONTINUED
if (bestmove != bestMoveNotFound) { // return best one
return bestmove;
} // end if bestmove
for (int i = firstCell ; i <= lastCell ; i++) { // try first one open
int firstAvailableComputerMove = mostStrategicMove[i];
if (((computerStatus & (1 << firstAvailableComputerMove)) == 0)
&& ((userStatus & (1 << firstAvailableComputerMove)) == 0)) {
return firstAvailableComputerMove;
} // end if &&
} // end for
return bestMoveNotFound; // return no more moves
} // end best move
Refactoring
**** bestMove () CONTINUED
*Cohesive sets no class variables
*Size still somewhat large but tolerable
*Testable yes one type several tests
Refactoring
Conditionals
Refactoring
Conditionals should not be too
complex. If they are complex,
refactor them to make simple
methods making readability and
understandability better.
Refactoring
FOR EXAMPLE
if (((computerStatus & (1 << potentialComputerMove)) ==

0) && ((userStatus & (1 << potentialComputerMove)) == 0))
((userStatus & (1 << j)) == 0))
if (((computerStatus & (1 <<firstAvailableComputerMove))
== 0) && ((userStatus & (1 <firstAvailableComputerMove))
Refactoring
REFACTORINGS
Decomposing Conditional
Consolidating Conditional Statements
Consolidate Duplicate Conditional Fragments
Replace Nested Conditional with Guard Clauses
Remove Control Flag
Not all of these are covered in detail.
Rather the resulting code for TTT is shown.
Refactoring
if (((computerStatus & (1 << firstAvailableComputerMove)) == 0)
&& ((userStatus & (1 << firstAvailableComputerMove)) == 0))
BECOMES
public boolean cellEmpty
(int computerStatus,int potentialComputerMove,int userStatus) {
return ((computerStatus & (1 << potentialComputerMove)) == 0)
&& ((userStatus & (1 << potentialComputerMove)) == 0);
} // end cellEmpty
Refactoring
if ((getComputerStatus() & (1 << i)) != 0)
BECOMES
public boolean squareOccupied (int i, int playerStatus) {
return ((playerStatus & (1 << i)) != 0);
} // end squareOccupied
WITH
REUSED
3 times
if (squareOccupied (i, getComputerStatus()))

Refactoring

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Refactoring

Uploaded by

Copyright:

Available Formats

Refactoring

Refactoring is a technique which identifies

building, decomposing, and moving methods

methods or classes are too LARGE,

public class Movie {

public Customer (String name) { _name = name; }

// add frequent renter points

a code cluster is setting one variable

public String statement() {

Calls the new method

Should be in the rental

private double getCharge(Rental each)

the method and result

Problem temp in loop

Cannot make subclasses of movie

Cannot make subclasses of movie

New Release Price

Cannot make subclasses of movie

public class Movie {

public Movie(String title, int priceCode) {

public Movie(String title, int priceCode) {

Once it is moved, we can replace

Take one leg of case statement at a time.

Create an overiding method for the getCharge method.

And some other BIG refactoring.

Replace Data Value with Object

Change Value to Reference

Replace Record with Data Class

Change Reference to Value

Replace Type with Data Class

Replace Array with Object

Replace Type Code with Subclasss

Duplicate Observed Data

Replace Type Code with

Change Unidirectional Direction to Bidirectional

Change Bidirectional Direction to Unidirectional

Replace Magic Number with Symbolic Constant

Introduce Parameter Object

Remove Setting Method

Separate Query from Modifier

Replace Constructor with Factory

Replace Parameter with Explicit Methods

Replace Error Code with Exception

Replace Parameter with Method Replace Exception with Test

Pull Up Constructor Body

Form Template Method

Push Down Method

Replace Inheritance with

Push Down Field

Replace Delegation with

A. Format the code according to supplied standards

Change the name of the method.

Rename constants, variables methods

Image crossImage; // user image

int white; // White's current position. The computer is white.

Write get and set methods for ALL class variables

public int getComputerStatus () { return computerStatus; }

public void setComputerStatus (int computerStatus)

Constants and Variables

Review all the constants and variables to make sure

int mostStrategicMove[] = {4,0,2,6,8,1,3,5,7};// square order of importanc

Replace Magic Number with Symbolic Constant

Create a constant, name it after the meaning, and

Add a constant to store the values of these magic