读书笔记 -《重构-改善既有代码的设计》Part3

谁家的书

于 2020-11-04 17:53:10 发布

阅读量243

点赞数

分类专栏：重构

本文链接：https://blog.csdn.net/kelekeleni/article/details/109495601

版权

重构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

读书笔记 -《重构-改善既有代码的设计》Part3

上一节读书笔记 -《重构-改善既有代码的设计》Part2
下一节读书笔记 -《重构-改善既有代码的设计》Part4

读书笔记 -《重构-改善既有代码的设计》Part3

重新组织函数

Extract Method

处理好临时变量

Inline Method

你有一个临时变量，只被一个简单的表达式赋值一次，而它妨碍了其他重构手法。

将所有对该变量的一你用动作，替换为对它赋值的那个表达式自身。

检查函数，确定它不具备多态性
找出这个函数的所有被调用点
将这个函数的所有被调用点替换为函数本体
编译、测试
删除该函数的定义

int getRating() {
    return (moreThanFiveLateDeliveries()) ? 2 : 1;
}

boolean moreThanFiveLateDeliveries() {
    return _numberOfLateDeliveries > 5;
}

int getRating() {
    return (_numberOfLateDeliveries > 5) ? 2 : 1;
}

Inline Temp - 内联临时变量

将所有对该变量的引用动作，替换为对它赋值的那个表达是自身

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

return anOrder.basePrice() > 1000;

Replace Temp with Query

往往你的程序会以一个临时变量保存某一表达式的运算结果。

将这个表达式提炼到一个独立函数中。

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

double basePrice() {
    return _quantity * _itemPrice;
}
......
if (basePrice() > 1000) {
	......   
} else {
    ......
}

找出只被赋值依次的临时变量
将该临时变量生命为 final
编译 – 看看是否只被赋值一次
将 ”对该临时变量赋值“ 的语句提炼成函数
编译、测试
在该临时变量身上实施 Inline Temp

Example

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

=>
int basePrice() {
    return _quantity * _itemPrice;
}

double getDiscountFactor() {
    if (basePrice() > 1000) {
        return 0.95;
    } else {
        return 0.98;
    }
}

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

Introduce Explaining Variable 引入解释性变量

顾名思义，解释性变量的最大好处就是可读性增强。

if (!platform.toUpperCase().indexOf("MAC") > -1 &&
    browser.toUpperCase().indexOf("IE") > -1 &&
    wasInitialized() && resize > 0) {
    ......
}

=>
    
final boolean isMacOs = platform.toUpperCase().indexOf("MAC");
final boolean isIEBrowser = browser.toUpperCase().indexOf("IE");
final boolean wasResized = resize > 0;

if (!isMacOs && isIEBrowser && wasInitialized() && wasResized) {
    ......
}

当然我们也能 Extract Method，提炼函数

boolean isMacOs() {
    return platform.toUpperCase().indexOf("MAC");
}

boolean isIEBrowser() {
    return browser.toUpperCase().indexOf("IE");
}

boolean wasResized() {
    return resize > 0;
}

if (!isMacOs() && isIEBrowser() && wasInitialized() && wasResized()) {
    ......
}

Split Temporary Variable 分解临时变量

你的程序有某个临时变量被赋值超过一次，它既不是循环变量，也不被用于收集计算结果。

针对每次赋值，创造一个独立、对应的临时变量

double temp = 2 * (_height + _width);
System.out.println(temp);
temp = _height * _width;
System.out.println(temp);

final double perimeter = 2 * (_height + _width);
System.out.println(perimeter);
final double area = _height * _width;
System.out.println(area);

Remove Assignments to Parameters 移除对参数的赋值

对一个参数进行赋值，以一个临时变量取代该参数的位置

在 java 中，不要对参数进行赋值。

int discout (int inputVal, int quantity, int yearToData) {
	if (inputVal > 50) {
        inputVal -= 2;
    }
    ......
}

int discout (int inputVal, int quantity, int yearToData) {
	int input = inputVal;
    if (inputVal > 50) {
        input -= 2;
    }
    ......
}

java 中参数可以标示为 final

Replace Method with Method Object 以函数对象取代函数

一个大型函数，其中对局部变量的使用使你无法采用 Extract Method

将这个函数放进一个单独对象中，如此一来局部变量就成了对象内的字段，然后可以在同一个对象中将这个大型函数分解为多个小型函数

int gamma(int inputVal, int quantity, int yearToDate) {
    int importantValue1 = (inputVal * quantity) + delta();
    int importantValue2 = (inputVal * yearToDate) + 100;
    if ((yearToDate - importantValue1) > 100) {
        importantValue2 -= 20;
    }
    int importantValue3 = importantValue2 * 7;
    return importantValue3 - 2 * importantValue
}

class Gamma {
    private int inputVal;
    private int quantity;
    private int yearToDate;
    ...
    int compute() {
        ......
    }
}

Substitute Algorithm 替换算法

把某个算法替换为另一个更清晰的算法，将函数本体替换为另一个算法

String findName(String[] names) {
    for (String name : names) {
        if (name.equals("X")) {
            return "X-Man1";
        }
        
        if (name.equals("Y")) {
            return "Y-Man2";
        }
    }
}

String findName(String[] names) {
	List<String> lst = Arrays.asList(new String[] {"X-Man1", "Y-Man2"});
	for (String name : names) {
    	if (-1 != lst.indexOf(name)) {
        	return lst.get([lst.indexOf(name)]);  // 此处会被编译器优化
    	}
	}
}

在对象之间搬移特性

即使你是一个经验丰富的程序员，一开始设计对象时也会出现错误，需要重构去优化。

Move Method

如果一个类有太多行为，或如果一个类与另一个类有太多交互而高度耦合，就要考虑这些行为能否被搬移了。

检查源类中被源函数所使用的一切特性，考虑它们是否该被搬移
检查源类的子类和超类，看看是否有该函数的其它声明

如果出现其他声明，你或许无法进行搬移，除非目标类也同样表现出多态性

Move Field

对于一个字段，其所驻类之外的另一个类中有更多函数使用了它，就该考虑搬移字段

Extract Class

某个类做了应该由多个类做的事，应该分别建立单一任务的类来分担这些事情，职责明确，更易维护。

Inline Class 将类内联化

Inline Class 正好与 Extract Class 相反，如果一个类不在承担足够责任，可以用 Inline Class 重构代码。

Hide Delegate 隐藏委托关系

class Person {
    Department _department;
    
    public Department getDepartment() {
        return _department;
    }
    
    public void setDepartment(Department department) {
        _department = department;
    }
}

class Department {
    private String _chargeCode;
    private Person _manager;
    
    public Department(Person manager) {
        _manager = manager;
    }
    
    public Person getManager() {
        return _manager;
    }
}
......
manager = somebody.getDepartment().getManager();

上面的代码就把 Manager 的从属关系暴露出去了。为隐藏 Department，在 Person 中建立一个简单的委托函数

public Person getManager() {
    return _department.getManager();
}

用户调用代码变成了

manager = somebody.getManager();

Remove Middle Man 移除中间人

某个类做了过多的简单委托动作，让客户直接调用被委托的类。

过多的 Hide Delegate 也会有麻烦，很难界定什么时候该减少这类封装。如果代码在发展过程中开始变得不适用，就该到重构的时候了。

Introduce Foreign Method 引入外加函数

需要为提供服务的类增加一个函数，但你无法修改这个类

在客户类中建立一个函数，并以第一参数形式传入一个服务类实例

Date newDate == new Date(pre.getYear(), pre.getMonth(), pre.getDate() + 1);

public static Date nextDate(Date pre) {
    return new Date(pre.getYear(), pre.getMonth(), pre.getDate() + 1);
}

Date newDate = nextDate(pre);

Introduce Local Extension 引入本地扩展

你需要为服务类提供一些额外函数，但你无法修改这个类。

建立一个新类，使它包含这些额外函数。让这个扩展成为源类的子类或包装类。

拓展类

class MyDate extends Date {
    public MyDate(String dateString) {
        super(dateString);
    }
    
    public Date MyDateNext() {
        return new Date(this.getYear(), this.getMonth(), this.getDate() + 1);
    }
    
    ......
}