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

简介: 重构改善既有代码的设计完结篇,汇总了全部的重构手法。看看哪些手法对你的项目能有所帮助…

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

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

相关文章
|
1月前
|
设计模式 算法 程序员
程序员为何需要反复修改Bug?探寻代码编写中的挑战与现实
作为开发者,我们在日常开发过程中,往往会遇到反复修改bug的情况,而且不能一次性把代码写的完美无瑕,其实开发项目是一项复杂而富有挑战性的任务,即使经验丰富的程序员也难以在一次性编写完美无瑕地完成代码,我个人觉得一次性写好代码是不可能完成的事情。虽然在设计之初已经尽力思考全面,并在实际操作中力求精确,但程序员仍然需要花费大量时间和精力来调试和修复Bug。那么本文就来分享程序员需要反复修改Bug的原因,以及在开发中所面临的复杂性与挑战。
76 1
程序员为何需要反复修改Bug?探寻代码编写中的挑战与现实
|
8月前
|
设计模式 算法 Java
设计模式第十五讲:重构 - 改善既有代码的设计(下)
设计模式第十五讲:重构 - 改善既有代码的设计
249 0
|
8月前
|
设计模式 Java 测试技术
设计模式第十五讲:重构 - 改善既有代码的设计(上)
设计模式第十五讲:重构 - 改善既有代码的设计
265 0
|
设计模式
重构·改善既有代码的设计.03之重构手法(上)
之前的重构系列中,介绍了书中提到的重构基础,以及识别代码的坏味道。今天继续第三更,讲述那些重构手法(上)。看看哪些手法对你的项目能有所帮助......
19222 1
重构·改善既有代码的设计.03之重构手法(上)
|
设计模式 测试技术
重构·改善既有代码的设计.02之代码的“坏味道”
之前在《重构·改善既有代码的设计.01》中初步了解了重构的基本前提,基础原则等入门知识。今天我们继续第二更......
173 1
重构·改善既有代码的设计.02之代码的“坏味道”
|
设计模式 程序员 开发者
重构·改善既有代码的设计.01之入门基础
近期在看Martin Fowler著作的《重构.改善既有代码的设计》这本书,这是一本经典著作。书本封面誉为软件开发的不朽经典。书中从一个简单的案例揭示了重构的过程以及最佳实践。同时给出了重构原则,何时重构,以及重构的手法。用来改善既有代码的设计,提升软件的可维护性。
592 1
重构·改善既有代码的设计.01之入门基础
重构改善既有代码的设计---笔记
重构改善既有代码的设计---笔记
190 0
|
设计模式 Java 程序员
《重构:改善既有代码的设计》-学习笔记一(+实战解析)
《重构:改善既有代码的设计》-学习笔记一(+实战解析)
176 0
《重构:改善既有代码的设计》-学习笔记一(+实战解析)
|
程序员
《重构:改善既有代码的设计》-学习笔记二(+实战解析)
《重构:改善既有代码的设计》-学习笔记二(+实战解析)
534 0
《重构:改善既有代码的设计》-学习笔记二(+实战解析)
|
Java 数据库 容器
项目重构,我是如何优化大量屎一样的 if else 代码的?
  目录:   if else策略模式1、首先抽象业务处理器2、将业务处理器和其支持处理的类型放到一个容器中,java里Map就是最常用的容器之一3、定义不同的处理器4、测试类   前段时间,我将公司系统中的批量审单的功能进行了重构,用到了java的并发编程进行异步化处理,数据库的乐观锁机制处理多线程并发更新数据。   其中批量审单的业务处理涉及到多种任务类型,对应不同的业务方法进行处理,比如转仓,转快递,添加赠品,删除赠品,拆分订单,批量驳回,批量作废等等,其中就用到了策略模式。
232 0
http://www.vxiaotou.com