Refactoring II

1
Refactoring II
2
Books

• Design Patterns is the classic book by Erich
  Gamma Richard Helm Ralph Johnson and John
  Vlissides
  
• Basically a catalog of program organizations
• Reading it is rather like reading a dictionary
• Although equally applicable to Java the examples
  are in C
  
• AntiPatterns Refactoring Software
  Architectures and Projects in Crisis by William
  J. Brown Raphael C. Malveau Hays W. Skip
  McCormick Thomas J. Mowbray
• Describes bad patterns and how to fix them
• More fun to read
• Refactoring Improving the Design of Existing
  Code by Martin Fowler with contributions from
  Kent Beck and others
  
• Very clear plenty of useful ideas very
  readable
  
• Much of this lecture will be based on this book

3
Design Patterns and Refactoring

• Design Patterns describe good solutions to common
  (or at least not extremely rare) design
  problems
  
• Design Patterns are always specified in UML
• Model-View-Controller is a very common Design
  Pattern
  
• An Antipattern is a common but poor Design
  Pattern
  
• Antipatterns can be refactored into better
  designs
  
• Refactoring is rearranging existing code while
  maintaining the same functionality
  
• Refactoring is usually done in terms of applying
  some Design Pattern

4
UML review I

• Key
• means public visibility
• means protected visibility
• - means private visibility
• means default (package) visibility
• static variables are underlined

5
UML review II
6
Bad smells

• Where did this term come from
• If it stinks change it.
  --Grandma Beck discussing child-rearing
  philosophy
  
• The basic idea is that there are things in code
  that cause problems
  
• Duplicated code
• Long methods
• Etc.
• A common reason for refactoring is that you need
  to add features that dont fit well with the
  existing design
  
• Any time you change working code you run the
  risk of breaking it
  
• A good test suite makes refactoring much easier
  and safer

7
An example

• Some time ago I was working on code to evaluate
  expressions
  
• Expressions can be parsed into a tree structure

• Now what
• You could walk the tree and at each node use a
  switch statement to do the right thing
  
• I discovered a better solution

8
Using my Command pattern

• class Add extends Command int evaluate( )
  int v1 lhs.evaluate().value
  int v2 rhs.evaluate().value value v1
  v2 return value

• To evaluate the entire tree evaluate the root
  node
  
• This is just a rough description there are a lot
  of other details to consider
  
• Some operands are unary
• You have to look up the values of variables
• Etc.

9
Duplicated code I

• If the same code fragment occurs in more than one
  place within a single class you can use Extract
  Method
  
• Turn the fragment into a method whose name
  explains the purpose of the method
  
• Any local variables that the method requires can
  be passed as parameters (if there arent too many
  of them!)
  
• If the method changes a local variable see
  whether it makes sense to return that as the
  value of the method (possibly changing the name
  of the method to indicate this)
• If the method changes two or more variables you
  need other refactorings to fix this problem

10
Duplicated code II

• If the same code fragment occurs in sibling
  classes you can use Extract Method in both
  classes then use Pull Up Method
  
• Use ExtractMethod in each class
• Be sure the code is identical
• If necessary adjust the method signatures to be
  identical
  
• Copy the extracted method to the common
  superclass
  
• Delete one subclass method
• Compile and test
• Delete the other subclass method
• Compile and test

11
Duplicated code III

• If the same code fragment occurs in unrelated
  classes you can use Extract Method in one class
  then
  
• Use this class as a component in the other class
  or
  
• Invoke the method from the other class or
• Move the method to a third class and refer to it
  from both of the original classes
  
• In any case you need to decide where the method
  makes most sense and put it there

12
Duplicated code IV

• If almost the same code fragment occurs in
  sibling classes use Extract Method to separate
  the similar bits from the different bits and use
  Form Template Method
• Ive done this one recently and it makes a good
  example

13
The Template Method

• Template Methods lead to an inverted control
  structure
  
• A superclass calls methods in its subclass
• Template methods are so fundamental that they
  can be found in almost every abstract class
  
• Template Method uses inheritance
• A similar pattern Strategy Pattern uses
  delegation rather than inheritance

14
Big fish and little fish

• The scenario big fish and little fish move
  around in an ocean
  
• Fish move about randomly
• A big fish can move to where a little fish is
  (and eat it)
  
• A little fish will not move to where a big fish is

15
The move() method

• General outline of the method
• public void move() choose a random
  direction // same for both find the
  location in that direction // same for both
  check if its ok to move there //
  different if its ok make the move
  // same for both
• My solution
• Extract the check on whether its ok to move
• In the Fish class put the actual (template)
  move() method
  
• Create an abstract okToMove() method in the Fish
  class
  
• Implement okToMove() in each subclass

16
The Fish refactoring

• Note how this works When a BigFish tries to
  move it uses the move() method in Fish
  
• But the move() method in Fish uses the
  okToMove(locn) method in BigFish
  
• And similarly for LittleFish

17
To be continued...