1. Bad smell in codes – Part 1
If it stinks change it.
Presented By:
Fuad Bin Omar Rashed Kibria
fuad@code71.com rashed@code71.com
www.code71.com www.code71.com
2. Smells to be covered
•Duplicated code
•Long method
•Long parameter list
•Divergent change
•Shotgun surgery
3. Duplicated Code
Smell
• Same code structure in more than
one place.
Refactor
Extract method and invoke it from
both the places.
4. Extract Method
• You have a code fragment that can
be grouped together.
• Turn the fragment into a method
whose name explains the
purpose of the method.
10. Duplicated Code
Smell
• Code is similar but not the same
Refactor:
• Use Extract Method to
separate the similar bits from the
different bits.
• Use Form Template Method.
11. 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.
13. Duplicated Code
Smell
• Methods do the same thing with a
different algorithm
Refactor:
• Choose the clearer of the two
algorithms Use
• Use Substitute Algorithm.
14. Substitute Algorithm
• You want to replace an algorithm
with one that is clearer.
• Replace the body of the method
with the new algorithm.
15. Substitute
Algorithm(Contd.)
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 "";
}
16. Substitute Algorithm
(Contd.)
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 "";
}
17. Duplicated Code
Smell
• Duplicated code in two unrelated class.
Refactor:
• Use Extract Class in one class.
• Use the new component to the other.
• Decide where the method makes sense.
18. Extract Class
• You have one class doing work that
should be done by two.
• Create a new class and move the
relevant fields and methods from
the old class into the new class.
20. Long method
• Object program having short
methods live best and longest.
• Little methods are the most valuable.
• Longer methods are difficult to
understand.
21. Long method
• Give methods a good name.
• Whenever you feel the need to comment
something make it a method.
– Group of lines
– Even if it is a single line
– Even if method call is longer than code itself.
– Method length is not the key here.
– What the method does and how it does it is
important.
24. Replace temp with query
• 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.
The new method can then be
used in other methods
30. 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.
31. Preserve whole object
int low = daysTempRange().getLow();
int high = daysTempRange().getHigh();
withinPlan = plan.withinRange(low,
high);
33. Replace method with
method object
• You have a long method that uses local
variables in such a way that you cannot
apply Extract Method
• Turn the method into its own object
so that all the local variables become
fields on that object. You can then
decompose the method into other
methods on the same object.
34. Replace method with
method object
class Order
{
double price()
{
double primaryBasePrice;
double secondaryBasePrice;
double tertiaryBasePrice;
// long computation;
}
}
36. Long method
Smell
• Too many conditions and loops
Refactor
• With loops, extract the loop and the
code within the loop into its own
method.
• Use Decompose Conditional.
37. Decompose Conditional
• You have a complicated conditional
(if-then-else) statement.
• Extract methods from the
condition, then part, and else
parts
40. Long Parameter List
Smell
• A method call requires passing long list of
parameters.
Refactor
• Use Replace Parameter with Method, Preserve
whole object or Introduce Parameter Object.
41. Replace Parameter With
Method
int basePrice = _quantity * _itemPrice;
discountLevel = getDiscountLevel();
double finalPrice =
discountedPrice (basePrice,discountLevel);
int basePrice = _quantity * _itemPrice;
double finalPrice =
discountedPrice(basePrice);
42. Divergent Change
Smell
• One class is commonly changed in different ways for
different reasons.
Refactor
• Use Extract class by identifying everything that changes
for a particular cause and put them all together.
43. Shotgun Surgery
Smell
• A small changes in the code force changes in different classes.
Refactor
• Use Move Method and Move Field to put all the changes into
a single class.
• If no current class looks like a good candidate, create one.
• use Inline Class to bring a whole bunch of behavior together.
44. Move Method
• A method is, or will be, using or used
by more features of another class
than the class on which it is defined.
• Create a new method with a
similar body in the class it uses
most. Either turn the old method
into a simple delegation, or
remove it altogether.
46. Move Field
• A field is, or will be, used by another
class more than the class on which it
is defined.
• Create a new field in the target
class, and change all its users.
49. References
1. Refactoring: Improving the Design of Existing Code
By
Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts
2. www.refactoring.com