1. 前言
本文是代码重构系列的最后一篇啦。前面三篇《重构·改善既有代码的设计.01之入门基础》、《重构·改善既有代码的设计.02之代码的“坏味道”》、《重构·改善既有代码的设计.03之重构手法（上）》介绍了基础入门，代码异味，还有部分重构手法。今天继续总结重构手法下篇，从条件表达式、函数调用、以及类继承关系上阐述了各种重构手法，希望对项目能有所帮助。另外本文更新后该系列就完结了，感谢各位看官的指点。
2. 简化条件表达式
“分支逻辑”和“操作细节”分离。
1、Decompose Conditional 分解条件表达式。
复杂的条件语句（if-then-else）。 改造前：
代码语言：javascript复制if(date.before(SUMMER_START) || date.after(SUMMER_END)) {
charge = quantity * _winterRate * _winterServiceCharge;
} else {
charge = quantity * _summerRate;
}改造后：
代码语言：javascript复制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 合并条件表达式。
有一系列条件测试，都得到相同结果。将这些测试合并为一个条件表达式，并将这个条件表达式提炼成一个独立函数。 改造前：
代码语言：javascript复制double disabilityAmount(){
if(_seniority < 2) {
return 0;
}
if(_monthDisabled > 12) {
return 0;
}
if(_isPartTime) {
return 0;
}
// todo...
}改造后：
代码语言：javascript复制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 合并重复的条件片段。
条件表达式的每个分支上有着相同的一段代码。 改造前：
代码语言：javascript复制if(isSpecialDeal()) {
total = price * 0.95;
send();
} else {
total = price * 0.98;
send();
}改造后：
代码语言：javascript复制if(isSpecialDeal()) {
total = price * 0.95;
} else {
total = price * 0.98;
}
send();4、Remove Control Flag 移除控制标记。
循环体中，通常需要判断何时停止条件检查。有时会引入某个控制变量来起到循环判断的作用。建议以break或continue或return 语句取代控制标记。 改造前：
代码语言：javascript复制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();
}
}
}
}改造后：
代码语言：javascript复制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…的条件表达式；如果某个条件极为罕见，就应该单独检查该条件，并在该条件为真时立刻从函数中返回（如参数校验判断）。这样的单检查称为“卫语句”。 卫语句要么就从函数中返回，要么就抛出一个异常。 改造前：
代码语言：javascript复制double getPayment(){
double result;
if(_isDead) {
result = deadAmount();
} else {
if(_isSeparated) {
result = separatedAmount();
} else {
if(_isRetired) {
result = retiredAmount();
} else {
result = normalAmount();
}
}
}
return result;
}改造后：
代码语言：javascript复制double getPayment(){
if(_isDead) {
return deadAmount();
}
if(_isSeparated) {
return separatedAmount();
}
if(_isRetired) {
return retiredAmount();
}
return normalAmount();
}6、Replace Conditional with Polymorphism 以多态取代条件表达式。
改造前：
代码语言：javascript复制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;
}
}改造后：
代码语言：javascript复制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对象。 改造前：
代码语言：javascript复制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();
}改造后：
代码语言：javascript复制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 引入断言。
一段代码需要对程序状态做出某种假设。以断言明确表现这种假设。 改造前：
代码语言：javascript复制double getExpenseLimit() {
return (_expenseLimit != NULL_EXPENSE) ? _expenseLimit : _primaryProject.getMemberExpenseLimit();
}改造后：
代码语言：javascript复制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 添加参数。
为函数添加一个对象参数，让该对象带进函数所需信息。 动机： 你必须修改一个函数，而修改后的函数需要一些过去没有的信息，因此你需要给该函数添加一个参数。 改造前：
代码语言：javascript复制double getExpenseLimit(double limit) {
// todo...
}
// 需要添加一个参数
double getExpenseLimit(double limit, Date date) {
// todo...
}改造后：
代码语言：javascript复制double getExpenseLimit(ExpenseLimit limitObj) {
// todo...
double limit = limitObj.getLimit();
Date date = limitObj.getDate();
}
class ExpenseLimit {
double limit;
Date date;
}但是需要警惕引用传递。其实我并不推荐整个对象传参。当你传整个参数时，对于这个函数你不能准确的说出这个函数所使用的参数。有可能对象包含了5个参数，而你理论上只需要3个。 这时候宁可将参数依次卸载参数列表中。不过所带来的影响是代码参数过长。如果过长，也是不太友好的。 推荐：适当使用参数列表和对象参数，必要时可以进行函数重载更简洁说明函数意图。比如：
代码语言：javascript复制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 移除参数。
移除函数体无用参数。 改造前：
代码语言：javascript复制double getExpenseLimit(double limit, Date date) {
return limit * 0.98;
}改造后：
代码语言：javascript复制double getExpenseLimit(double limit) {
return limit * 0.98;
}4、Separate Query from Modifier 将查询函数和修改函数分离。
某个函数既返回对象状态值，又修改对象状态。
5、Parameterize Method 令函数携带参数。
若干函数做了类似的工作，但在函数本体中却包含了不同的值。 改造前：
代码语言：javascript复制class Employee {
void tenPercentRaise() {
salary *= 1.1;
}
void fivePercentRaise() {
salary *= 1.05;
}
}改造后：
代码语言：javascript复制class Employee {
void raise(double factor) {
salary *= (1 factor);
}
}6、Replace Parameter with Explicit Methods 以明确函数取代参数。
有一个函数，其中完全取决于参数值而采取不同行动。 改造前：
代码语言：javascript复制void setValue(String name, int value) {
if(name.equals("height")) {
_height = value;
return ;
}
if(name.equals("width")) {
_width = value;
return ;
}
}改造后：
代码语言：javascript复制void setHeight(int value) {
_height = value;
}
void setWidth(int value) {
_width = value;
}7、Preserve Whole Object 保持对象完整。
从某个对象中取出若干值，将它们作为某一个函数调用时的参数。 改造前：
代码语言：javascript复制int low = daysTempRange().getLow();
int high = daysTempRange().getHigh();
withinPlan = plan.withinRange(low, high);改造后：
代码语言：javascript复制withinPlan = plan.withinRange(daysTempRange());注： 该方法总有两面。如果你传的是数值，被调用函数就只依赖于这些数值，而不依赖它们所属的对象。但如果你传递的是整个对象，被调用函数所在的对象就需要依赖参数对象。如果这样，会使你的依赖结构恶化，那么就不该使用该方法。
8、Replace Parameter with Methods 以函数取代参数。
对象调用某个函数，并将所得结果作为参数，传递给另一个函数。而接受该参数的函数本身也能够调用前一个函数。 改造前：
代码语言：javascript复制int basePrice = _quantity * _itemPrice;
discountLevel = getDiscountLevel();
double finalPrice = discountedPrice(basePrice, discountLevel);改造后：
代码语言：javascript复制int basePrice = _quantity * _itemPrice;
double finalPrice = discountedPrice(basePrice);
double discountedPrice(int basePrice) {
discountLevel = getDiscountLevel();
......
}9、Introduce Parameter Object 引入参数对象。
某些参数总是很自然地同时出现。以一个对象取代这些参数。 改造前：
代码语言：javascript复制void amountInvoicedIn(Date start, Date end);
void amountReceicedIn(Date start, Date end);
void amountOverdueIn(Date start, Date end);改造后：
代码语言：javascript复制void amountInvoicedIn(DateRange dateRange);
void amountReceicedIn(DateRange dateRange);
void amountOverdueIn(DateRange dateRange);
class DateRange {
Date start;
Date end;
...
}10、Remove Setting Method 移除设值函数。
类中的某个字段应该在对象创建时被设值，然后就不再改变。 改造前：
代码语言：javascript复制class Acount {
private String _id;
Acount(String id) {
setId(id);
}
public void setId(String arg) {
_id = arg;
}
}改造后：
代码语言：javascript复制class Acount {
private final String _id;
Acount(String id) {
_id = id;
}
}一般我们在处理多线程运算的时候，此类方式使用的比较多。
11、Hide Method 隐藏函数。
有一个函数，从来没有被其他任何类使用到。将这个函数修改为private。
12、Replace Constructor with Factory Method 以工厂函数取代构造函数。
你希望在创建对象时，不仅仅是简单的构建动作。 改造前：
代码语言：javascript复制Employee (int type) {
_type = type;
}改造后：
代码语言：javascript复制static Employee create(int type) {
return new Employee(type);
}13、Encapsulate Downcast 封装向下转型。
某个函数返回的对象，需要由函数调用者执行向下转型。将向下转型动作移动到函数中。 改造前：
代码语言：javascript复制Object lastReading() {
return readings.lastElement();
}改造后：
代码语言：javascript复制Reading lastReading() {
return (Reading) readings.lastEmelent();
}14、Replace Error Code with Exception 以异常取代错误码。
某个函数返回一个特定的代码，用以表示某种错误情况。 改造前：
代码语言：javascript复制int withdraw(int amount) {
if(amount > _balance) {
return -1;
} else {
_balance -= amount;
return 0;
}
}改造后：
代码语言：javascript复制void withdraw(int amount) throws BalanceException {
if(amount > _balance) {
throw new BalanceException("xxx");
}
_balance -= amount;
}15、Replace Exception with Test 以测试取代异常。
面对一个调用者可以预先检查的条件，你抛出了一个异常。 改造前：
代码语言：javascript复制double getValueForPeriod(int period) {
try {
return _values[period];
} catch(ArrayIndexOutofBoundsException e) {
return 0;
}
}改造后：
代码语言：javascript复制double getValueForPeriod(int period) {
if(period >= _values.length) {
return 0;
}
return _values[period];
}异常只应该被用于异常的、罕见的行为，也就是那些产生意料之外的错误行为，而不应该成为条件检查的替代品。如果你可以合理期望调用者在调用函数之前先检查某个条件，那么就应该提供一个测试，而调用者应该使用它。
4. 处理概括关系
专门用来处理类的概括关系（继承关系），其中主要是将函数上下移动于继承体系之中。
1、Pull Up Field 字段上移。
两个子类拥有相同的字段。将该字段移至超类。 改造前：
代码语言：javascript复制class Employee{
...
}
class Salesman extends Employee {
String name;
...
}
class Manager extends Employee {
String name;
...
}改造后：
代码语言：javascript复制class Employee{
String name;
}
class Salesman extends Employee {
...
}
class Manager extends Employee {
...
}2、Pull Up Method 函数上移。
有些函数，在各个子类中产生完全相同的结果。 改造前：
代码语言：javascript复制class Employee{
...
}
class Salesman extends Employee {
String getName(){
return _name;
}
...
}
class Manager extends Employee {
String getName(){
return _name;
}
...
}改造后：
代码语言：javascript复制class Employee {
String getName(){
return _name;
}
}
class Salesman extends Employee {
...
}
class Manager extends Employee {
...
}3、Pull Up Constructor Body 构造函数本体上移。
各个子类中拥有一些构造函数，他们的本地几乎完全一致。 改造前：
代码语言：javascript复制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;
}
}改造后：
代码语言：javascript复制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 提炼超类。
两个类具有相似特性。为这两个类建立一个超类，将相同特性移至超类。与提炼子类相反。 改造前：
代码语言：javascript复制class Cat {
void eat(){
...
}
void miaomiao(){
...
}
}
class Bird {
void eat(){
...
}
void fly(){
...
}
}改造后：
代码语言：javascript复制class Animal {
void eat(){
...
}
}
class Cat extends Animal {
void miaomiao(){
...
}
}
class Bird extends Animal {
void fly(){
...
}
}8、Extract Interface 提炼接口。
改造前：
代码语言：javascript复制double charge(Employee emp, int days) {
int base = emp.getRate() * days;
if(emp.hasSpecialSkill()) {
return base * 1.05;
} else {
return base;
}
}改造后：
代码语言：javascript复制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 以委托取代继承。
某个子类只使用了超类接口的一部分，或是根本不需要继承而来的数据。 改造前：
代码语言：javascript复制// 这里的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;
}
}改造后：
代码语言：javascript复制// 这里将继承改为类委托
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. 小结
到此已经汇总了书中全部的重构手法，依旧保持个人观点，部分重构手法是以牺牲一定的代码阅读性为代价。且书中提到的多数重构手法还是要视具体编程场景而定。避免错误引用。 重构手法和设计模式一样，均为编程模式中的最佳实践。是符合大多数场景和行为的思想或方法的总结。记住是大多数。了解最佳实践有助于提高平常的编码习惯以及提升代码的维护性，可修改性。但如果被错误引用，程序将因为过度设计或引用而变得臃肿。
