final double perimeter = 2 * (_height + _width);
System.out.println (perimeter);
final double area = _height * _width;
System.out.println (area);
Motivation
Variables should not have more than one responsibility.
Using a temp for two different things is very confusing for the reader.
7. Remove Assignments to Parameters
The code assign to a parameter
int discount (int inputVal, int quantity, int yearToDate) {
if (inputVal > 50) inputVal -= 2;
to
int discount (int inputVal, int quantity, int yearToDate) {
int result = inputVal;
if (inputVal > 50) result -= 2;
Motivation
You can change the internals of object is passed but do not point to another object.
Use only the parameter to represent what has been passed.
8. Replace Method with Method Object
You have a long method that uses local variables in such a way that you cannot apply Extract Method.
class Order...
double price() {
double primaryBasePrice;
double secondaryBasePrice;
double tertiaryBasePrice;
// long computation;
...
}
to
class Order...
double price(){
return new PriceCalculator(this).compute()
}
}
class PriceCalculato...
compute(){
double primaryBasePrice;
double secondaryBasePrice;
double tertiaryBasePrice;
// long computation;
return ...
}
Motivation
When a method has lot of local variables and applying decomposition is not possible
This sample does not really needs this refactoring, but shows the way to do it.
Class Account
int gamma (int inputVal, int quantity, int yearToDate) {
int importantValue1 = (inputVal * quantity) + delta();
int importantValue2 = (inputVal * yearToDate) + 100;
if ((yearToDate - importantValue1) > 100)
importantValue2 -= 20;
int importantValue3 = importantValue2 * 7;
// and so on.
return importantValue3 - 2 * importantValue1;
}
}
to
class Gamma...
private final Account _account;
private int inputVal;
private int quantity;
private int yearToDate;
private int importantValue1;
private int importantValue2;
private int importantValue3;
Gamma (Account source, int inputValArg, int quantityArg, int yearToDateArg) {
_account = source;
inputVal = inputValArg;
quantity = quantityArg;
yearToDate = yearToDateArg;
}
int compute () {
importantValue1 = (inputVal * quantity) + _account.delta();
importantValue2 = (inputVal * yearToDate) + 100;
if ((yearToDate - importantValue1) > 100)
importantValue2 -= 20;
int importantValue3 = importantValue2 * 7;
// and so on.
return importantValue3 - 2 * importantValue1;
}
int gamma (int inputVal, int quantity, int yearToDate) {
return new Gamma(this, inputVal, quantity,yearToDate).compute();
}
9. Substitute Algorithm
You want to replace an algorithm with one that is clearer.
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 "";
}
to
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 "";
}
Motivation
Break down something complex into simpler pieces.
Makes easier apply changes to the algorithm.
Substituting a large, complex algorithm is very difficult; making it simple can make the substitution tractable.
7. Moving features between elements
10. 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.
class Class1 {
aMethod()
}
class Class2 { }
to
class Class1 { }
class Class2 {
aMethod()
}
Motivation
When classes do to much work or when collaborate too much and are highly coupled
11. 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.
class Class1 {
aField
}
class Class2 { }
to
class Class1 { }
class Class2 {
aField
}
Motivation
12. 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.
class Person {
name,
officeAreaCode,
officeNumber,
getTelephoneNumber()
}
to
class Person {
name,
getTelephoneNumber()
}
class TelephoneNumber {
areaCode,
number,
getTelephoneNumber()
}
Motivation
Classes grow. Split them when:
subsets of methods seem to be together
subsets of data usually change together or depend on each other
13. Inline Class
A class isn't doing very much. Move all its features into another class and delete it.
class Person {
name,
getTelephoneNumber()
}
class TelephoneNumber {
areaCode,
number,
getTelephoneNumber()
}
to
class Person {
name,
officeAreaCode,
officeNumber,
getTelephoneNumber()
}
Motivation
After refactoring normally there are a bunch of responsibilities moved out of the class, letting the class with little left.
14. Hide Delegate
A client is calling a delegate class of an object. Create methods on the server to hide the delegate.
class ClientClass {
//Dependencies
Person person = new Person()
Department department = new Department()
person.doSomething()
department.doSomething()
}
to
class ClientClass {
Person person = new Person()
person.doSomething()
}
class Person{
Department department = new Department()
department.doSomething()
}
The solution
class ClientClass{
Server server = new Server()
server.doSomething()
}
class Server{
Delegate delegate = new Delegate()
void doSomething(){
delegate.doSomething()
}
}
// The delegate is hidden to the client class.
// Changes won't be propagated to the client they will only affect the server
class Delegate{
void doSomething(){...}
}
Motivation
Key of encapsulation. Classes should know as less as possible of other classes.
> manager = john.getDepartment().getManager();
class Person {
Department _department;
public Department getDepartment() {
return _department;
}
public void setDepartment(Department arg) {
_department = arg;
}
}
class Department {
private String _chargeCode;
private Person _manager;
public Department (Person manager) {
_manager = manager;
}
public Person getManager() {
return _manager;
}
...
to
> manager = john.getManager();
class Person {
...
public Person getManager() {
return _department.getManager();
}
}
15. Remove Middle Man
A class is doing too much simple delegation. Get the client to call the delegate directly.
class ClientClass {
Person person = new Person()
person.doSomething()
}
class Person{
Department department = new Department()
department.doSomething()
}
to
class ClientClass {
//Dependencies
Person person = new Person()
Department department = new Department()
person.doSomething()
department.doSomething()
}
Motivation
When the "Middle man" (the server) does to much is time for the client to call the delegate directly.
16. Introduce Foreign Method
A server class you are using needs an additional method, but you can't modify the class. Create a method in the client class with an instance of the server class as its first argument.
Date newStart = new Date(previousEnd.getYear(),previousEnd.getMonth(),previousEnd.getDate()+1);
to
Date newStart = nextDay(previousEnd);
private static Date nextDay(Date date){
return new Date(date.getYear(),date.getMonth(),date.getDate()+1);
}
Motivation
When there is a lack of a method in class that you use a lot and you can not change that class.
17. Introduce Local Extension
A server class you are using needs several additional methods, but you can't modify the class. Create a new class that contains these extra methods. Make this extension class a subclass or a wrapper of the original.
class ClientClass(){
Date date = new Date()
nextDate = nextDay(date);
private static Date nextDay(Date date){
return new Date(date.getYear(),date.getMonth(),date.getDate()+1);
}
}
to
class ClientClass() {
MfDate date = new MfDate()
nextDate = nextDate(date)
}
class MfDate() extends Date {
...
private static Date nextDay(Date date){
return new Date(date.getYear(),date.getMonth(),date.getDate()+1);
}
}
Motivation
8. ORGANIZING DATA
18. Self Encapsulate Field
You are accessing a field directly, but the coupling to the field is becoming awkward. Create getting and setting methods for the field and use only those to access the field.
private int _low, _high;
boolean includes (int arg) {
return arg >= _low && arg <= _high;
}
to
private int _low, _high;
boolean includes (int arg) {
return arg >= getLow() && arg <= getHigh();
}
int getLow() {return _low;}
int getHigh() {return _high;}
Motivation Allows a subclass to override how to get that information with a method and that it supports more flexibility in managing the data, such as lazy initialization.
19. Replace Data Value with Object
You have a data item that needs additional data or behavior. Turn the data item into an object
class Order...{
private String _customer;
public Order (String customer) {
_customer = customer;
}
}
to
class Order...{
public Order (String customer) {
_customer = new Customer(customer);
}
}
class Customer {
public Customer (String name) {
_name = name;
}
}
Motivation Simple data items aren't so simple anymore.
20. Change Value to Reference
You have a class with many equal instances that you want to replace with a single object. Turn the object into a reference object.
class Order...{
public Order (String customer) {
_customer = new Customer(customer);
}
}
class Customer {
public Customer (String name) {
_name = name;
}
}
to
//Use Factory Method
class Customer...
static void loadCustomers() {
new Customer ("Lemon Car Hire").store();
new Customer ("Associated Coffee Machines").store();
new Customer ("Bilston Gasworks").store();
}
private void store() {
_instances.put(this.getName(), this);
}
public static Customer create (String name) {
return (Customer) _instances.get(name);
}
Motivation Reference objects are things like customer or account. Each object stands for one object in the real world, and you use the object identity to test whether they are equal.
21. Change Reference to Value
You have a reference object that is small, immutable, and awkward to manage. Turn it into a value object
new Currency("USD").equals(new Currency("USD")) // returns false
to
// Add `equals` and `hashCode` to the Currency class
class Currency{
...
public boolean equals(Object arg) {
if (! (arg instanceof Currency)) return false;
Currency other = (Currency) arg;
return (_code.equals(other._code));
}
public int hashCode() {
return _code.hashCode();
}
}
// Now you can do
new Currency("USD").equals(new Currency("USD")) // now returns true
Motivation Working with the reference object becomes awkward. The reference object is immutable and small. Used in distributed or concurrent systems.
22. Replace Array with Object
You have an array in which certain elements mean different things. Replace the array with an object that has a field for each element
Performance row = new Performance();
row.setName("Liverpool");
row.setWins("15");
Motivation Arrays should be used only to contain a collection of similar objects in some order.
23. Duplicate Observed Data
You have domain data available only in a GUI control, and domain methods need access. Copy the data to a domain object. Set up an observer to synchronize the two pieces of dataMotivation To separate code that handles the user interface from code that handles the business logic.
24. Change Unidirectional Association to Bidirectional
You have two classes that need to use each other's features, but there is only a one-way link. Add back pointers, and change modifiers to update both sets
class Order...
Customer getCustomer() {
return _customer;
}
void setCustomer (Customer arg) {
if (_customer != null) _customer.friendOrders().remove(this);
_customer = arg;
if (_customer != null) _customer.friendOrders().add(this);
}
private Customer _customer;
class Customer...
void addOrder(Order arg) {
arg.setCustomer(this);
}
private Set _orders = new HashSet();
Set friendOrders() {
/** should only be used by Order */
return _orders;
}
}
}
// Many to Many
class Order... //controlling methods
void addCustomer (Customer arg) {
arg.friendOrders().add(this);
_customers.add(arg);
}
void removeCustomer (Customer arg) {
arg.friendOrders().remove(this);
_customers.remove(arg);
}
class Customer...
void addOrder(Order arg) {
arg.addCustomer(this);
}
void removeOrder(Order arg) {
arg.removeCustomer(this);
}
}
Motivation When the object referenced needs access access to the object that refer to it.
25. Change Bidirectional Association to Unidirectional
You have a two-way association but one class no longer needs features from the other. Drop the unneeded end of the associationMotivation If Bidirectional association is not needed, reduce complexity, handle zombie objects, eliminate interdependency
26. Replace Magic Number with Symbolic Constant
You have a literal number with a particular meaning. Create a constant, name it after the meaning, and replace the number with it
double potentialEnergy(double mass, double height) {
return mass * GRAVITATIONAL_CONSTANT * height;
}
static final double GRAVITATIONAL_CONSTANT = 9.81;
Motivation Avoid using Magic numbers.
27. Encapsulate Field
There is a public field. Make it private and provide accessors
public String _name
to
private String _name;
public String getName() {return _name;}
public void setName(String arg) {_name = arg;}
Motivation You should never make your data public.
28. Encapsulate Collection
A method returns a collection. Make it return a read-only view and provide add/remove methods
class Person {
Person (String name){
HashSet set new HashSet()
}
Set getCourses(){}
void setCourses(:Set){}
}
to
class Person {
Person (String name){
HashSet set new HashSet()
}
Unmodifiable Set getCourses(){}
void addCourses(:Course){}
void removeCourses(:Course){}
}
Motivation
Encapsulated reduce the coupling of the owning class to its clients.
The getter should not return the collection object itself.
The getter should return something that prevents manipulation of the collection and hides unnecessary details.
There should not be a setter for collection, only operations to add and remove elements.
29. Remove Record with data class
You need to interface with a record structure in a traditional programming environment. Make a dumb data object for the record.
Motivation
Copying a legacy program
Communicating a structured record with a traditional programming API or database.
30. 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.
class Person{
O:Int;
A:Int;
B:Int;
AB:Int;
bloodGroup:Int;
}
to
class Person{
bloodGroup:BloodGroup;
}
class BloodGroup{
O:BloodGroup;
A:BloodGroup;
B:BloodGroup;
AB:BloodGroup;
}
Motivation Statically type checking.
31. Replace Type Code with Subclasses
You have an immutable type code that affects the behavior of a class. Replace the type code with subclasses.
class Employee...
private int _type;
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
Employee (int type) {
_type = type;
}
}
to
abstract int getType();
static Employee create(int type) {
switch (type) {
case ENGINEER:
return new Engineer();
case SALESMAN:
return new Salesman();
case MANAGER:
return new Manager();
default:
throw new IllegalArgumentException("Incorrect type code value");
}
}
Motivation
Execute different code depending on the value of a type.
When each type code object has unique features.
32. Replace Type Code with State/Strategy
You have a type code that affects the behavior of a class, but you cannot use subclassing. Replace the type code with a state object
class Employee {
private int _type;
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
Employee (int type) {
_type = type;
}
int payAmount() {
switch (_type) {
case ENGINEER:
return _monthlySalary;
case SALESMAN:
return _monthlySalary + _commission;
case MANAGER:
return _monthlySalary + _bonus;
default:
throw new RuntimeException("Incorrect Employee");
}
}
}
}
to
class Employee {
private final EmployeeType employeeType;
public Employee(int type) {
this.employeeType = EmployeeType.newType(type);
}
int payAmount() {
return employeeType.salary();
// switch (employeeType) {
// case EmployeeType.ENGINEER:
// return _monthlySalary;
// case EmployeeType.SALESMAN:
// return _monthlySalary + _commission;
// case EmployeeType.MANAGER:
// return _monthlySalary + _bonus;
// default:
// throw new RuntimeException("Incorrect Employee");
// }
}
}
public abstract class EmployeeType {
abstract int getTypeCode();
abstract int salary();
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
public static EmployeeType newType(int code) {
switch (code) {
case ENGINEER:
return new Engineer();
case SALESMAN:
return new SaleMan();
case MANAGER:
return new Manager();
default:
throw new IllegalArgumentException("Incorrect Employee code");
}
}
}
public class Engineer extends EmployeeType {
@Override
int getTypeCode() {
return ENGINEER;
}
@Override
int salary() {
return _monthlySalary;
}
}
public class Manager extends EmployeeType {
@Override
int getTypeCode() {
return MANAGER;
}
@Override
int salary() {
return _monthlySalary + _bonus;
}
}
public class SaleMan extends EmployeeType {
@Override
int getTypeCode() {
return SALEMAN;
}
@Override
int salary() {
return _monthlySalary + _commission;
}
}
Motivation
It uses either the state or strategy pattern
Links
32. Replace Subclass with Fields
You have subclasses that vary only in methods that return constant data. Change the methods to superclass fields and eliminate the subclasses
abstract class Person {
abstract boolean isMale();
abstract char getCode();
...
}
class Male extends Person {
boolean isMale() {
return true;
}
char getCode() {
return 'M';
}
}
class Female extends Person {
boolean isMale() {
return false;
}
char getCode() {
return 'F';
}
}
to
class Person{
protected Person (boolean isMale, char code) {
_isMale = isMale;
_code = code;
}
boolean isMale() {
return _isMale;
}
static Person createMale(){
return new Person(true, 'M');
}
static Person createFemale(){
return new Person(false, 'F');
}
}
Motivation
Subclasses that consists only of constant methods is not doing enough to be worth existing.
Remove such subclasses completely by putting fields in the superclass.
Remove the extra complexity of the subclasses.
9. SIMPLIFYING CONDITIONAL EXPRESSIONS
33. Decompose Conditional
You have a complicated conditional (if-then-else) statement. Extract methods from the condition, then part, and else parts
if (notSummer(date))
charge = winterCharge(quantity);
else charge = summerCharge (quantity);
Motivation
Highlight the condition and make it clearly what you are branching on.
Highlight the reason for the branching
34. Consolidate Conditional Expression
You have a sequence of conditional tests with the same result. Combine them into a single conditional expression and extract it
double disabilityAmount() {
if (_seniority < 2) return 0;
if (_monthsDisabled > 12) return 0;
if (_isPartTime) return 0;
// compute the disability amount
to
double disabilityAmount() {
if (isNotEligableForDisability()) return 0;
// compute the disability amount
Motivation
Makes the check clearer by showing that you are really making a single check
Clarify your code (replaces a statement of what you are doing with why you are doing it.)
35. Consolidate Duplicate Conditional Fragments
The same fragment of code is in all branches of a conditional expression. Move it outside of the expression.
if (isSpecialDeal()) {
total = price * 0.95;
send();
}
else {
total = price * 0.98;
send();
}
to
if (isSpecialDeal()) {
total = price * 0.95;
}
else {
total = price * 0.98;
}
send();
Motivation Makes clearer what varies and what stays the same.
36. Remove Control Flag
You have a variable that is acting as a control flag for a series of boolean expressions. Use a break or return instead
void checkSecurity(String[] people) {
boolean found = false;
for (int i = 0; i < people.length; i++) {
if (! found) {
if (people[i].equals ("Don")){
sendAlert();
found = true;
}
if (people[i].equals ("John")){
sendAlert();
found = true;
}
}
}
}
to
void checkSecurity(String[] people) {
for (int i = 0; i < people.length; i++) {
if (people[i].equals ("Don")){
sendAlert();
break; // or return
}
if (people[i].equals ("John")){
sendAlert();
break; // or return
}
}
}
Motivation
Control flag are used to determine when to stop looking, but modern languages enforce the use of break and continue
Make the real purpose of the conditional much more clear.
37. Replace Nested Conditional with Guard Clauses
A method has conditional behavior that does not make clear the normal path of execution. Use guard clauses for all the special cases
double getPayAmount() {
double result;
if (_isDead) result = deadAmount();
else {
if (_isSeparated) result = separatedAmount();
else {
if (_isRetired) result = retiredAmount();
else result = normalPayAmount();
};
}
return result;
};
to
double getPayAmount() {
if (_isDead) return deadAmount();
if (_isSeparated) return separatedAmount();
if (_isRetired) return retiredAmount();
return normalPayAmount();
};
Motivation
If the condition is an unusual condition, check the condition and return if the condition is true.
This kind of check is often called a guard clause [Beck].
If you are using an if-then-else construct you are giving equal weight to the if leg and the else leg.
This communicates to the reader that the legs are equally likely and important.
Instead the guard clause says, "This is rare, and if it happens, do something and get out."
38. Replace Conditional with Polymorphism
You have a conditional that chooses different behavior depending on the type of an object. Move each leg of the conditional to an overriding method in a subclass. Make the original method abstract
class Employee {
private int _type;
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
Employee (int type) {
_type = type;
}
int payAmount() {
switch (_type) {
case ENGINEER:
return _monthlySalary;
case SALESMAN:
return _monthlySalary + _commission;
case MANAGER:
return _monthlySalary + _bonus;
default:
throw new RuntimeException("Incorrect Employee");
}
}
}
}
to
class Employee...
static final int ENGINEER = 0;
static final int SALESMAN = 1;
static final int MANAGER = 2;
void setType(int arg) {
_type = EmployeeType.newType(arg);
}
int payAmount() {
return _type.payAmount(this);
}
}
class Engineer...
int payAmount(Employee emp) {
return emp.getMonthlySalary();
}
}
Motivation
Avoid writing an explicit conditional when you have objects whose behavior varies depending on their types.
Switch statements should be less common in object oriented programs
39. Introduce Null Object
You have repeated checks for a null value. Replace the null value with a null object
if (customer == null) plan = BillingPlan.basic();
else plan = customer.getPlan();
to
class Customer {}
class NullCusomer extends Customer {}
Motivation
The object, depending on its type, does the right thing. Null objects should also apply this rule.
Use Null Object Pattern is the little brother of Special Case Pattern.
40. Introduce Assertion
A section of code assumes something about the state of the program. Make the assumption explicit with an assertion
double getExpenseLimit() {
// should have either expense limit or a primary project
return (_expenseLimit != NULL_EXPENSE) ?
_expenseLimit:
_primaryProject.getMemberExpenseLimit();
}
Assertions are conditional statements that are assumed to be always true.
Assertion failures should always result in unchecked exceptions.
Assertions usually are removed for production code.
As communication aids: they help the reader understand the assumptions the code is making.
As debugging aids: assertions can help catch bugs closer to their origin.
10. MAKING METHOD CALLS SIMPLER
41. Rename method
The name of a method does not reveal its purpose. Change the name of the method
getinvcdtlmt()
to
getInvoiceableCreditLimit
Motivation Methods names must communicate their intention.
42. Add Parameter
A method needs more information from its caller. Add a parameter for an object that can pass on this information
getContact()
to
getContact(:Date)
Motivation After changed a method you require more information.
43. Remove Parameter
A parameter is no longer used by the method body. Remove it
getContact(:Date)
to
getContact()
Motivation A parameter is no more needed.
44. Separate Query from Modifier
You have a method that returns a value but also changes the state of an object. Create two methods, one for the query and one for the modification
getTotalOutStandingAndSetReadyForSummaries()
to
getTotalOutStanding()
SetReadyForSummaries()
Motivation Signaling methods with side effects and those without.
45. Parameterize Method
Several methods do similar things but with different values contained in the method body. Create one method that uses a parameter for the different values
fivePercentRaise()
tenPercentRaise()
to
raise(percentage)
Motivation Removes duplicate code and increases flexibility.
46. Replace Parameter with Explicit Methods
You have a method that runs different code depending on the values of an enumerated parameter. Create a separate method for each value of the parameter
void setValue (String name, int value) {
if (name.equals("height")){}
_height = value;
return;
}
if (name.equals("width")){
_width = value;
return;
}
Assert.shouldNeverReachHere();
}
You are getting several values from an object and passing these values as parameters in a method call. Send the whole object instead
int low = daysTempRange().getLow();
int high = daysTempRange().getHigh();
withinPlan = plan.withinRange(low, high);
to
withinPlan = plan.withinRange(daysTempRange());
Motivation
Make parameters list robust to changes
Make code more readeable
Remove possible duplicate code already done in the object passed
Negative: It creates a dependency between the parameter object and the called.
48. Replace Parameter with Method
An object invokes a method, then passes the result as a parameter for a method. The receiver can also invoke this method. Remove the parameter and let the receiver invoke the method
A field should be set at creation time and never altered. Remove any setting method for that field
class Employee{
setImmutableValue()
}
to
class Employee{
¯\_(ツ)_/¯
}
Motivation Make your intention clear: If you don't want that field to change once is created, then don't provide a setting method (and make the field final).
51. Hide Method
A method is not used by any other class. Make the method private
class Employee{
public method()
}
to
class Employee{
private method()
}
Motivation Whenever a method is not needed outside its class it should be hidden
52. Replace Constructor with Factory Method
You want to do more than simple construction when you create an object. Replace the constructor with a factory method
Employee (int type) {
_type = type;
}
to
static Employee create(int type) {
return new Employee(type);
}
Motivation Create an object depending on its subclasses (types). Constructors can only return an instance of the object that is asked for so a Factory method is needed.
53. Encapsulate Downcast
A method returns an object that needs to be downcasted by its callers. Move the downcast to within the method
Motivation Provide as result type, the most specific type of the method signature. If the signature is to general, check the uses the clients do of that method and if coherent, provide a more specific one.
54. Replace Error Code with Exception
A method returns a special code to indicate an error. Throw an exception instead
int withdraw(int amount) {
if (amount > _balance)
return -1;
else {
_balance -= amount;
return 0;
}
}
to
void withdraw(int amount) throws BalanceException {
if (amount > _balance)
throw new BalanceException();
_balance -= amount;
}
Motivation When a program that spots an error can't figure out what to do about it. It needs to let its caller know, and the caller may pass the error up the chain.
55. Replace Exception with Test
You are throwing a checked exception on a condition the caller could have checked first. Change the caller to make the test first
Do not overuse Exceptions they should be used for exceptional behavior (behavior that is unexpected).
Do not use them as substitute for conditional tests.
Check expected wrong conditions before before calling the operation.
11. DEALING WITH GENERALIZATION
56. Pull up field
Two subclasses have the same field. Move the field to the superclass
class Salesman extends Employee{
String name;
}
class Engineer extends Employee{
String name;
}
to
class Employee{
String name;
}
class Salesman extends Employee{}
class Engineer extends Employee{}
Motivation
Removes the duplicate data declaration.
Allows to move behavior from the subclasses to the superclass.
57. Pull Up Method
You have methods with identical results on subclasses. Move them to the superclass
class Salesman extends Employee{
String getName();
}
class Engineer extends Employee{
String getName();
}
to
class Employee{
String getName();
}
class Salesman extends Employee{}
class Engineer extends Employee{}
Motivation
Eliminates duplicated behavior.
58. Pull Up Constructor Body
You have constructors on subclasses with mostly identical bodies. Create a superclass constructor; call this from the subclass methods
class Manager extends Employee...
public Manager (String name, String id, int grade) {
_name = name;
_id = id;
_grade = grade;
}
to
public Manager (String name, String id, int grade) {
super (name, id);
_grade = grade;
}
Motivation
Constructors are not the same as methods.
Eliminates duplicated behavior.
59. Push Down Method
Behavior on a superclass is relevant only for some of its subclasses. Move it to those subclasses.
class Employee{
int getQuota();
}
class Salesman extends Employee{}
class Engineer extends Employee{}
to
class Salesman extends Employee{
int getQuota();
}
class Engineer extends Employee{}
Motivation When a method makes only sense in the subclass.
60. Push Down Field
A field is used only by some subclasses. Move the field to those subclasses
class Employee{
int quota;
}
class Salesman extends Employee{}
class Engineer extends Employee{}
to
class Salesman extends Employee{
int quota;
}
class Engineer extends Employee{}
Motivation When a field makes only sense in the subclass.
61. Extract Subclass
A class has features that are used only in some instances. Create a subclass for that subset of features
class JobItem {
getTotalPrices()
getUnitPrice()
getEmployee()
}
to
JobItem {
getTotalPrices()
getUnitPrice()
}
class class LabotItem extends JobItem {
getUnitPrice()
getEmployee()
}
Motivation When a class has behavior used for some instances of the class and not for others.
62. Extract Superclass
You have two classes with similar features. Create a superclass and move the common features to the superclass
class Department{
getTotalAnnualCost()
getName()
getHeadCount
}
class Employee{
getAnnualCost()
getName()
getId
}
to
class Party{
getAnnualCost()
getName()
}
class Department {
getAnnualCost()
getHeadCount
}
class Employee {
getAnnualCost()
getId
}
Motivation When two classes that do similar things in the same way or similar things in different ways.
63. Extract Interface
Several clients use the same subset of a class's interface, or two classes have part of their interfaces in common. Extract the subset into an interface
class Employee {
getRate()
hasSpecialSkill()
getName()
getDepartment()
}
If only a particular subset of a class's responsibilities is used by a group of clients.
If a class needs to work with any class that can handle certain requests.
Whenever a class has distinct roles in different situations.
64. Collapse Hierarchy
A superclass and subclass are not very different. Merge them together
class Employee{ }
class Salesman extends Employee{ }
to
class Employee{ }
Motivation When a subclass that isn't adding any value.
65. 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
class Site{}
class ResidentialSite extends Site{
getBillableAmount()
}
class LifelineSite extends Site{
getBillableAmount()
}
to
class Site{
getBillableAmount()
getBaseAmount()
getTaxAmount()
}
class ResidentialSite extends Site{
getBaseAmount()
getTaxAmount()
}
class LifelineSite extends Site{
getBaseAmount()
getTaxAmount()
}
Motivation
Use Inheritance with polymorphism for eliminating duplicate behavior that is slightly different.
When there are two similar methods in a subclass, bring them together in a superclass.
66. 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
class Vector{
isEmpty()
}
class Stack extends Vector {}
to
class Vector {
isEmpty()
}
class Stack {
Vector vector
isEmpty(){
return vector.isEmpty()
}
}
Motivation
Using delegation makes clear that you are making only partial use of the delegated class.
You control which aspects of the interface to take and which to ignore.
Mechanics
67. Replace Delegation with Inheritance
You're using delegation and are often writing many simple delegations for the entire interface. Make the delegating class a subclass of the delegate
class Person {
getName()
}
class Employee {
Person person
getName(){
return person.getName()
}
}
to
class Person{
getName()
}
class Employee extends Person{}
Motivation
If you are using all the methods of the delegate.
If you aren't using all the methods of the class to which you are delegating, you shouldn't use it.
Beware of is that in which the delegate is shared by more than one object and is mutable. Data sharing is a responsibility that cannot be transferred back to inheritance.
12. BIG REFACTORINGS
68. Tease Apart Inheritance
You have an inheritance hierarchy that is doing two jobs at once. Create two hierarchies and use delegation to invoke one from the other
class Deal{}
class ActiveDeal extends Deal{}
class PassiveDeal extends Deal{}
class TabularActiveDeal extends ActiveDeal{}
class TabularPassiveDeal extends PassiveDeal{}
to
class Deal{
PresentationStyle presettationStyle;
}
class ActiveDeal extends Deal{}
class PassiveDeal extends Deal{}
class PresentationStyle{}
class TabularPresentationStyle extends PresentationStyle{}
class SinglePresentationStyle extends PresentationStyle{}
Motivation
Tangled inheritance leads to code duplication.
If every class at a certain level in the hierarchy has subclasses that begin with the same adjective, you probably are doing two jobs with one hierarchy.
Mechanics Note Identify the different jobs being done by the hierarchy. Create a two-dimensional(or x-dimensional) grid and label the axes with the different jobs.
Deal
Active Deal
Passive Deal
Tabular Deal
69. Convert Procedural Design to Objects
You have code written in a procedural style. Turn the data records into objects, break up the behavior, and move the behavior to the objects
class OrderCalculator{
determinePrice(Order)
determineTaxes(Order)
}
class Order{}
class OrderLine{}
to
class Order{
getPrice()
getTaxes()
}
class OrderLine{
getPrice()
getTaxes()
}
Motivation Use OOP (at least in JAVA)
70. Separate Domain from Presentation
You have GUI classes that contain domain logic. Separate the domain logic into separate domain classes
class OrderWindow{}
to
class OrderWindow{
Order order;
}
Motivation
Separates two complicated parts of the program into pieces that are easier to modify.
Allows multiple presentations of the same business logic.
Its worth is proved
71. Extract Hierarchy
You have a class that is doing too much work, at least in part through many conditional statements. Create a hierarchy of classes in which each subclass represents a special case
class BillingScheme{}
to
class BillingScheme{}
class BusinessBillingScheme extends BillingScheme{}
class ResidentialBillingScheme extends BillingScheme{}
class DisabilityBillingScheme extends BillingScheme{}
Motivation
A class as implementing one idea become implementing two or three or ten.
Keep the Single Responsibility Principle.
Use it with
Is a vital step before
If a field is used mostly by outer classes and before
When plenty of need to be added to a class.
Structure to implement
Use of
Similar to , but can be used if the type code changes during the life of the object or if another reason prevents subclassing.