《重构改善代码既有设计》读书笔记（二）-CSDN博客

本文链接：https://blog.csdn.net/weixin_44927066/article/details/132132529

《重构改善代码既有设计》第六章内容读书笔记

重新组织函数往往面对的问题是过长的函数，使用的手法是提炼函数

难点1：局部变量

查询取代局部变量
分解临时变量
以函数对象取代函数

难点2：参数

移除对参数的赋值

当提炼函数将长函数变得足够清晰后，便可使用替换算法优化其中的算法，或者使用内联函数回退掉不必要的函数提炼

提炼函数

有一段代码可以被组织在一起并独立出来：将这段代码放进一个独立函数中，并让函数名称解释该函数的用途

动机

用于过长的函数或一段需要注释才能让人理解的代码

目的是使函数能够自注释，强化代码清晰度。重构的结果就是函数越来越多，每个独立代码段都由函数名自注释。

做法

对局部变量的处理：

被提炼的函数仅读取局部变量 / 通过对象或引用传递的方式修改局部变量，直接将局部变量作为参数传入即可
被提炼函数需要对局部变量重新赋值
- 变量仅在新函数中使用：将声明移入
- 变量在原函数中有使用：用参数传入上文，返回值传给下文
- 复杂情况：需要返回的变量不止一个，需要挑选另一块代码重新提炼
以查询取代局部变量、以函数对象取代函数

范例

重构前：

void printOwing(double previousAmount) {
    Enumeration e = _oeders.elements();
    double outstanding = previousAmount * 1.2;
    
    printBanner();
    
    // calculate outstanding
    while (e.hasMoreElements()) {
        Order each = (Order) e.nextElements();
        outstanding += each.getAmount();
    }
    
    printDetails(outstanding); // 参数传入
}

重构后：

void printOwing(double previousAmount) {
    printBanner();
    double outstanding = getOutstanding(previousAmount * 1.2);
    printDetails(outstanding);
}

double getOutstanding(double initialValue) { // 参数传入上文，返回值传出下文
    double result = initialValue;
    Enumeration e = _oeders.elements(); // 声明移入
    while (e.hasMoreElements()) {
        Order each = (Order) e.nextElements();
        result += each.getAmount();
    }
    return result;
}

内联函数

一个函数的本体与名称同样清楚易懂：在函数调用点插入函数本体，然后移除该函数。

动机

函数的本体与名称同样清楚易懂，就没有必要引入一个间接层
一群组织不甚合理的函数，可以先把它们内联到一个大函数中，再进行提炼函数或以函数对象取代函数
使用了太多间接层，系统中几乎所有函数都只是一个简单委托。间接层有其价值，但不是所有的间接层都有价值。

内联临时变量

你有一个临时变量，只被一个简单表达式复制一次，而它妨碍了其他重构手法：将所有对该变量的引用动作，替换为对它赋值的那个表达式自身。

将所有对该变量的引用动作替换为对它赋值的那个表达式本身。常作为以查询取代临时变量的一个步骤

重构前：

double basePrice = anOrder.basePrice();
return (basePrice > 1000);

重构后：

return (anOrder.basePrice() > 1000);

以查询取代临时变量

你的程序以一个临时变量保存某一表达式的运算结果：将这个表达式提炼到一个独立函数中。将这个临时变量的所有引用点替换为对新函数的调用。此后，新函数就可被其他函数使用。

动机

临时变量的问题在于，它们是暂时的，而且只能在所属函数内使用，会驱使你写出更长的函数。如果把临时变量替换为一个查询，那么同一个类中的所有函数都可以获得这一信息（复用）

往往在提炼函数前运用。比较棘手的情况是，临时变量被赋值了多次，或者赋值方式受其他条件影响。此时可能需要先运用分解临时变量或查询和修改函数分离使情况变得简单一些，然后再替换临时变量。

范例

重构前：

double getPrice() {
    int basePrice = _quantity * _itemPrice;
    double discountFactor;
    if (basePrice > 1000) discountFactor = 0.95;
    else discountFactor = 0.98;
    return basePrice * discountFactor;
}

重构后：

double getPrice() {
    return basePrice() * discountFactor();
}

private int basePrice() {
    return _quantity * _itemPrice;
}

private double discountFactor() {
    if (basePrice() > 1000) return 0.95;
    return 0.98;
}

引入解释性变量

你有一个复杂的表达式：将该复杂表达式（或其中一部分）的结果放进一个临时变量，以此变量名称来解释表达式的用途。

动机

表达式可能非常复杂而难以阅读，这种情况下，临时变量可以帮助你将表达式分解为比较容易管理的形式。

条件逻辑：使用临时变量将每个条件子句提炼出来
较长算法：运用临时变量来解释每一步运算的意义

范例

重构前：

double price() {
    // base price - quantity discount + shipping
    return _quantity * _itemPrice - 
        Math.max(0, _quantity - 500) * _itemPrice * 0.05 + 
        Math.min(_quantity * _itemPrice * 0.1. 100.0);
}

使用引入解释性变量

double price() {
    final double basePrice = _quantity * _itemPrice;
    final double quantityDiscount = Math.max(0, _quantity - 500) * _itemPrice * 0.05;
    final double shipping = Math.min(basePrice * 0.1, 100.0);
    return basePrice - quantityDiscount + shipping;
}

使用提炼方法

double price() {
    return basePrice() - quantityDiscount() + shipping();
}

private double basePrice() {
    return _quantity * _itemPrice;
}

private double quantityDiscount() {
    return Math.max(0, _quantity - 500) * _itemPrice * 0.05;
}

private double shipping() {
    return Math.min(basePrice() * 0.1, 100.0);
}