1. 前言

本文是代码重构系列的最后一篇啦。前面三篇《重构·改善既有代码的设计.01之入门基础》、《重构·改善既有代码的设计.02之代码的“坏味道”》、《重构·改善既有代码的设计.03之重构手法（上）》介绍了基础入门，代码异味，还有部分重构手法。今天继续总结重构手法下篇，从条件表达式、函数调用、以及类继承关系上阐述了各种重构手法，希望对项目能有所帮助。另外本文更新后该系列就完结了，感谢各位看官的指点。

2. 简化条件表达式

“分支逻辑”和“操作细节”分离。

1、Decompose Conditional 分解条件表达式。

复杂的条件语句（if-then-else）。
改造前：

if(date.before(SUMMER_START) || date.after(SUMMER_END)) {charge = quantity * _winterRate * _winterServiceCharge;
} else {charge = quantity * _summerRate;
}

改造后：

if(notSummer(date)) {charge = winterCharge(quantity);
} else {charge = summerCharge(quantity);
}private boolean notSummer(Date date) {return date.before(SUMMER_START) || date.after(SUMMER_END);
}private double summerCharge(int quantity) {return quantity * _summerRate;
}private double winterCharge(int quantity) {return quantity * _winterRate * _winterServiceCharge;
}

2、Consolidate Conditional Expression 合并条件表达式。

有一系列条件测试，都得到相同结果。将这些测试合并为一个条件表达式，并将这个条件表达式提炼成一个独立函数。
改造前：

double disabilityAmount(){if(_seniority < 2) {return 0;    }if(_monthDisabled > 12) {return 0;    }if(_isPartTime) {return 0;    }// todo...
}

改造后：

double disabilityAmount(){if((_seniority < 2) || (_monthDisabled > 12) || _isPartTime) {return 0;    }// todo...
}或：
double disabilityAmount(){if(isDisability()) {return 0;    }// todo...
}boolean isDisability() {return (_seniority < 2) || (_monthDisabled > 12) || _isPartTime;
}

3、Consolidate Duplicate Conditional Fragments 合并重复的条件片段。

条件表达式的每个分支上有着相同的一段代码。
改造前：

if(isSpecialDeal()) {total = price * 0.95;send();
} else {total = price * 0.98;send();
}

改造后：

if(isSpecialDeal()) {total = price * 0.95;
} else {total = price * 0.98;
}send();

4、Remove Control Flag 移除控制标记。

循环体中，通常需要判断何时停止条件检查。有时会引入某个控制变量来起到循环判断的作用。建议以break或continue或return 语句取代控制标记。
改造前：

void check(String[] person) {boolean found = false;   // 控制标记for(int i = 0; i < person.length; i++) {if(!found) {if(person[i] == "tom") {found = true;sendAlert();                }if(person[i] == "jose") {found = true;sendAlert();                }          }    }}

改造后：

void check(String[] person) {boolean found = false;   // 控制标记for(int i = 0; i < person.length; i++) {if(!found) {if(person[i] == "tom") {sendAlert();break;                }if(person[i] == "jose") {sendAlert();    break;            }          }    }}

5、Replace Nested Conditional with Guard Clauses 以卫语句取代嵌套条件表达式。

条件表达式中，如果两条分支都是正常行为，使用形如if…else…的条件表达式；如果某个条件极为罕见，就应该单独检查该条件，并在该条件为真时立刻从函数中返回（如参数校验判断）。这样的单检查称为“卫语句”。
卫语句要么就从函数中返回，要么就抛出一个异常。
改造前：

double getPayment(){double result;if(_isDead) {result = deadAmount();    } else {if(_isSeparated) {result = separatedAmount();        } else {if(_isRetired) {result = retiredAmount();            } else {result = normalAmount();            }       }    }return result;
}

改造后：

double getPayment(){if(_isDead) {return deadAmount();    }if(_isSeparated) {return separatedAmount();        }if(_isRetired) {return retiredAmount();    }        return normalAmount(); 
}

6、Replace Conditional with Polymorphism 以多态取代条件表达式。

改造前：

class Employee {private EmployeeType _type;int payment() {switch(getType()) {case EmployeeType.ENGINEER:return _monthlySalary;case EmployeeType.SALESMAN:return _monthlySalary + _commission;case EmployeeType.MANAGER:return _monthlySalary + _bonus;default:throw new RuntimeException("error");                                                    }    }int getType() {return _type.getTypeCode();    }
}abstract class EmployeeType {abstract int getTypeCode();
}class Engineer extends EmployeeType {int getTypeCode(){return EmployeeType.ENGINEER;    }
}class Salesman extends EmployeeType {int getTypeCode(){return EmployeeType.SALESMAN;    }
}class Manager extends EmployeeType {int getTypeCode(){return EmployeeType.MANAGER;    }
}

改造后：

class Employee {private EmployeeType _type;int payment() {return _type.payment();  }
}abstract class EmployeeType {abstract int payment(Employee emp);
}class Engineer extends EmployeeType {int payment(Employee emp){return emp.getMonthlySalary();   }
}class Salesman extends EmployeeType {int payment(Employee emp){return emp.getMonthlySalary() + emp.getCommission();   }
}class Manager extends EmployeeType {int payment(Employee emp){return emp.getMonthlySalary() + emp.getBonus();   }
}

7、Introduce Null Object 引入Null对象。

将null替换为null对象。
改造前：

class Site {private Customer _customer;Customer getCustomer() {return _customer;    }
}class Customer {public Stirng getName() {...}public BillingPlan getPlan(){...}
}// 调用
Customer customer = site.getCustomer();
if(customer == null) {plan = BillingPlan.basic();
} else {plan = customer.getPlan();
}
String customerName;
if(customer == null) {customerName = "default";
} else {customerName = customer.getName();
}

改造后：

class Site {private Customer _customer;Customer getCustomer() {return _customer == ull ? Customer.newNull() : _customer;   }
}class Customer {public Stirng getName() {...}public BillingPlan getPlan(){...}public boolean isNull() {return false;    }static Customer newNull() {return new NullCustomer();    }
}// 定义NullCustomer空对象
class NullCustomer extends Customer{public boolean isNull() {return true;    }
}// 调用
Customer customer = site.getCustomer();
if(customer.isNull()) {plan = BillingPlan.basic();
} else {plan = customer.getPlan();
}
String customerName;
if(customer.isNull()) {customerName = "default";
} else {customerName = customer.getName();
}

8、Introduce Assertion 引入断言。

一段代码需要对程序状态做出某种假设。以断言明确表现这种假设。
改造前：

double getExpenseLimit() {return (_expenseLimit != NULL_EXPENSE) ? _expenseLimit : _primaryProject.getMemberExpenseLimit();
}

改造后：

double getExpenseLimit() {Assert.isTrue(_expenseLimit != NULL_EXPENSE || _primaryProject != null);return (_expenseLimit != NULL_EXPENSE) ? _expenseLimit : _primaryProject.getMemberExpenseLimit();
}

断言，请不要用它来检查“你认为应该为真”的条件，请只使用它来检查“一定必须为真”的条件。请勿滥用。
如果断言所指示的约束条件不能满足，代码是否仍能正常运行？ 如果可以，就把断言去掉。

3. 简化函数调用

容易被理解和被使用的接口，是开发良好面向对象软件的关键。

1、Rename Method 函数改名。

将复杂的处理过程分解成小函数。但是如果做的不好，会使你费尽周折却弄不清楚这些小函数各自的用途。要避免这种麻烦，关键在于给函数起一个好名称。
1、尽可能起一个良好名称的函数，顾名思义表达该函数的作用，而不是表达该函数如何做。
2、合理安排函数签名，如果重新安排参数顺序，能够帮助提供代码的清晰度。

2、Add Parameter 添加参数。

为函数添加一个对象参数，让该对象带进函数所需信息。
动机：
你必须修改一个函数，而修改后的函数需要一些过去没有的信息，因此你需要给该函数添加一个参数。
改造前：

double getExpenseLimit(double limit) {// todo...
}// 需要添加一个参数
double getExpenseLimit(double limit, Date date) {// todo...
}

改造后：

double getExpenseLimit(ExpenseLimit limitObj) {// todo...double limit = limitObj.getLimit();Date date = limitObj.getDate();
}class ExpenseLimit {double limit;Date date;
}

但是需要警惕引用传递。其实我并不推荐整个对象传参。当你传整个参数时，对于这个函数你不能准确的说出这个函数所使用的参数。有可能对象包含了5个参数，而你理论上只需要3个。 这时候宁可将参数依次卸载参数列表中。不过所带来的影响是代码参数过长。如果过长，也是不太友好的。
推荐：适当使用参数列表和对象参数，必要时可以进行函数重载更简洁说明函数意图。比如：

double getExpenseLimit(double limit) {this.getExpenseLimit(limit, new Date());
}double getExpenseLimit(double limit, Date date) {ExpenseLimit limitObj = new ExpenseLimit(limit, date);this.getExpenseLimit(limitObj);
}double getExpenseLimit(ExpenseLimit limitObj) {// todo...double limit = limitObj.getLimit();Date date = limitObj.getDate();
}class ExpenseLimit {double limit;Date date;
}

3、Remove Parameter 移除参数。

移除函数体无用参数。
改造前：

double getExpenseLimit(double limit, Date date) {return limit * 0.98;
}

改造后：

double getExpenseLimit(double limit) {return limit * 0.98;
}

4、Separate Query from Modifier 将查询函数和修改函数分离。

某个函数既返回对象状态值，又修改对象状态。

5、Parameterize Method 令函数携带参数。

若干函数做了类似的工作，但在函数本体中却包含了不同的值。
改造前：

class Employee {void tenPercentRaise() {salary *= 1.1;    }void fivePercentRaise() {salary *= 1.05;    }
}

改造后：

class Employee {void raise(double factor) {salary *= (1 + factor);    }
}

6、Replace Parameter with Explicit Methods 以明确函数取代参数。

有一个函数，其中完全取决于参数值而采取不同行动。
改造前：

void setValue(String name, int value) {if(name.equals("height")) {_height = value;return ;    }if(name.equals("width")) {_width = value;return ;    }
}

改造后：

void setHeight(int value) {_height = value;
}
void setWidth(int value) {_width = value;
}

7、Preserve Whole Object 保持对象完整。

从某个对象中取出若干值，将它们作为某一个函数调用时的参数。
改造前：

int low = daysTempRange().getLow();
int high = daysTempRange().getHigh();
withinPlan = plan.withinRange(low, high);

改造后：

withinPlan = plan.withinRange(daysTempRange());

注：
该方法总有两面。如果你传的是数值，被调用函数就只依赖于这些数值，而不依赖它们所属的对象。但如果你传递的是整个对象，被调用函数所在的对象就需要依赖参数对象。如果这样，会使你的依赖结构恶化，那么就不该使用该方法。

8、Replace Parameter with Methods 以函数取代参数。

对象调用某个函数，并将所得结果作为参数，传递给另一个函数。而接受该参数的函数本身也能够调用前一个函数。
改造前：

int basePrice = _quantity * _itemPrice;
discountLevel = getDiscountLevel();
double finalPrice = discountedPrice(basePrice, discountLevel);

改造后：

int basePrice = _quantity * _itemPrice;
double finalPrice = discountedPrice(basePrice);double discountedPrice(int basePrice) {discountLevel = getDiscountLevel();......
}

9、Introduce Parameter Object 引入参数对象。

某些参数总是很自然地同时出现。以一个对象取代这些参数。
改造前：

void amountInvoicedIn(Date start, Date end);
void amountReceicedIn(Date start, Date end);
void amountOverdueIn(Date start, Date end);

改造后：

void amountInvoicedIn(DateRange dateRange);
void amountReceicedIn(DateRange dateRange);
void amountOverdueIn(DateRange dateRange);class DateRange {Date start;Date end;...
}

10、Remove Setting Method 移除设值函数。

类中的某个字段应该在对象创建时被设值，然后就不再改变。
改造前：

class Acount {private String _id;Acount(String id) {setId(id);    }public void setId(String arg) {_id = arg;}
}

改造后：

class Acount {private final String _id;Acount(String id) {_id = id; }
}

一般我们在处理多线程运算的时候，此类方式使用的比较多。

11、Hide Method 隐藏函数。

有一个函数，从来没有被其他任何类使用到。将这个函数修改为private。

12、Replace Constructor with Factory Method 以工厂函数取代构造函数。

你希望在创建对象时，不仅仅是简单的构建动作。
改造前：

Employee (int type) {_type = type;
}

改造后：

static Employee create(int type) {return new Employee(type);
}

13、Encapsulate Downcast 封装向下转型。

某个函数返回的对象，需要由函数调用者执行向下转型。将向下转型动作移动到函数中。
改造前：

Object lastReading() {return readings.lastElement();
}

改造后：

Reading lastReading() {return (Reading) readings.lastEmelent();
}

14、Replace Error Code with Exception 以异常取代错误码。

某个函数返回一个特定的代码，用以表示某种错误情况。
改造前：

int withdraw(int amount) {if(amount > _balance) {return -1;    } else {_balance -= amount;return 0;    }
}

改造后：

void withdraw(int amount) throws BalanceException {if(amount > _balance) {throw new BalanceException("xxx");}_balance -= amount;
}

15、Replace Exception with Test 以测试取代异常。

面对一个调用者可以预先检查的条件，你抛出了一个异常。
改造前：

double getValueForPeriod(int period) {try {return _values[period];    } catch(ArrayIndexOutofBoundsException e) {return 0;    }
}

改造后：

double getValueForPeriod(int period) {if(period >= _values.length) {return 0;    }return _values[period];  
}

异常只应该被用于异常的、罕见的行为，也就是那些产生意料之外的错误行为，而不应该成为条件检查的替代品。如果你可以合理期望调用者在调用函数之前先检查某个条件，那么就应该提供一个测试，而调用者应该使用它。

4. 处理概括关系

专门用来处理类的概括关系（继承关系），其中主要是将函数上下移动于继承体系之中。

1、Pull Up Field 字段上移。

两个子类拥有相同的字段。将该字段移至超类。
改造前：

class Employee{...
}class Salesman extends Employee {String name;...
}class Manager extends Employee {String name;...
}

改造后：

class Employee{String name;
}class Salesman extends Employee {...
}class Manager extends Employee {...
}

2、Pull Up Method 函数上移。

有些函数，在各个子类中产生完全相同的结果。
改造前：

class Employee{...
}class Salesman extends Employee {String getName(){return _name;    }...
}class Manager extends Employee {String getName(){return _name;    }...
}

改造后：

class Employee {String getName(){return _name;    }
}class Salesman extends Employee {...
}class Manager extends Employee {...
}

3、Pull Up Constructor Body 构造函数本体上移。

各个子类中拥有一些构造函数，他们的本地几乎完全一致。
改造前：

class Employee {String _id;String _name;
}class Manager extends Employee {int _grade;public Manager(String name, String id, int grade) {_id = id;_name = name;_grade = grade;}
}

改造后：

class Employee {String _id;String _name;Employee(String name, String id) {_id = id;_name = name;    }
}class Manager extends Employee {int _grade;public Manager(String name, String id, int grade) {super(name, id);_grade = grade;}
}

4、Push Down Method 函数下移。

超类中的某个函数只与部分（而非全部）子类有关。将这个函数移到相关的那些子类去。恰好与函数上移相反。

5、Push DOwn Field 字段下移。

超类中的某个字段只被部分（而非全部）子类用到。恰好与字段上移相反。

6、Extract Subclass 提炼子类。

类中某些特性只被某些（而非全部）实例用到。可以新建一个子类，将上面所说的那一部分特性移到子类中。

7、Extract Superclass 提炼超类。

两个类具有相似特性。为这两个类建立一个超类，将相同特性移至超类。与提炼子类相反。
改造前：

class Cat {void eat(){...       }void miaomiao(){...    }
}class Bird {void eat(){...       }void fly(){...    }
}

改造后：

class Animal {void eat(){...       }
}class Cat extends Animal {void miaomiao(){...    }
}class Bird extends Animal {void fly(){...    }
}

8、Extract Interface 提炼接口。

改造前：

double charge(Employee emp, int days) {int base = emp.getRate() * days;if(emp.hasSpecialSkill()) {return base * 1.05;            } else {return base;    }
}

改造后：

interface Billable {public int getRate();public boolean hasSpecialSkill();
}class Employee implements Billable {double charge(Billable billable, int days) {int base = billable.getRate() * days;if(billable.hasSpecialSkill()) {return base * 1.05;            } else {return base;    }
}

当如果有若干个子类都实现了Billable的接口，他就会很有用。

9、Collapse Hierachy 折叠继承体系。

超类和子类之间无太大区别，可以将他们合为一体。

10、Form Template Method 塑造模板函数。

有一些子类，其中相应的某些函数以相同顺序执行类似的操作，但各个操作的细节上有所不同。可以将这些操作分别放进独立函数中，并保持他们都有相同的签名，于是源函数也就变得相同了。然后将源函数上移至超类中。

11、Replace Inheritance with Delegation 以委托取代继承。

某个子类只使用了超类接口的一部分，或是根本不需要继承而来的数据。
改造前：

// 这里的MyStack只需要push()、push()、size()、isEmpty()这四个函数。继承了vector只是因为使用了size()和isEmpty()方法
class MyStack extends Vector {public void push(Object element) {insertElementAt(element, 0);    }public Object pop(){Object result = firstElement();removeElementAt(0);return result;    }
}

改造后：

// 这里将继承改为类委托
class MyStack {Vector _vector;public void push(Object element) {_vector.insertElementAt(element, 0);    }public Object pop(){Object result = _vector.firstElement();_vector.removeElementAt(0);return result;    }public int size() {return _vector.size();    }public boolean isEmpty() {return _vector.isEmpty();    }
}

12、Replace Delegation with Inheritance 以继承取代委托。

与Replace Inheritance with Delegation刚好相反。在两个类之间使用委托关系，并经常为整个接口编写许多极简单的委托函数。

5. 小结

到此已经汇总了书中全部的重构手法，依旧保持个人观点，部分重构手法是以牺牲一定的代码阅读性为代价。且书中提到的多数重构手法还是要视具体编程场景而定。避免错误引用。
重构手法和设计模式一样，均为编程模式中的最佳实践。是符合大多数场景和行为的思想或方法的总结。记住是大多数。了解最佳实践有助于提高平常的编码习惯以及提升代码的维护性，可修改性。但如果被错误引用，程序将因为过度设计或引用而变得臃肿。