1. 前言

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

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. 小结

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

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

重构·改善既有代码的设计.04之重构手法（下）完结

1. 前言

2. 简化条件表达式

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

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

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

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

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

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

7、Introduce Null Object 引入Null对象。

8、Introduce Assertion 引入断言。

3. 简化函数调用

1、Rename Method 函数改名。

2、Add Parameter 添加参数。

3、Remove Parameter 移除参数。

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

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

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

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

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

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

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

11、Hide Method 隐藏函数。

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

13、Encapsulate Downcast 封装向下转型。

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

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

4. 处理概括关系

1、Pull Up Field 字段上移。

2、Pull Up Method 函数上移。

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

4、Push Down Method 函数下移。

5、Push DOwn Field 字段下移。

6、Extract Subclass 提炼子类。

7、Extract Superclass 提炼超类。

8、Extract Interface 提炼接口。

9、Collapse Hierachy 折叠继承体系。

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

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

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

5. 小结

热门文章

最新文章

相关课程

相关电子书

相关实验场景