第6章 重新组织函数

简介：

    本章重构手法中，很大一部分是对函数进行整理，使之更恰当地包装代码。

    重构的很多问题其实都来自“过长函数（Long Methods）”，要重构它是因为它往往包含过多的信息，这些信息又被他错综复杂的逻辑掩盖，不易鉴别。

    解决过长函数的重构方法，其中一个是“提炼函数（Extract Method）”，它把一段代码从源函数中提炼出来，放入一个单独的函数中；或者就是使用“内联函数（Inline Method）”，它将一个函数调用替换为函数本体，这样替换是因为提炼的函数没有做任何实质性的事情。

    提炼函数难点是：处理局部变量，如临时变量，参数等。

    提炼函数处理函数替换临时变量的一个方法：“以查询取代临时变量”，处理参数的方法：“移除对参数的赋值”。

 

Extract Method（提炼函数）

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

2.动机：

（1）如果每个函数的粒度都很小，那么函数被复用的机会更大。

（2）其次，这会使高层函数读起来像注释（小型函数要很好地命名）。

（3）最后，如果函数都是细粒度，那么函数的覆写也会更容易些。

（ps：函数命名长度不是问题，重要的是函数名称和函数本体之间的语义距离。）

3.做法：

（1）创造一个新函数，根据函数意图对它命名（即使你提炼的代码很简单，如只是一条消息或一个函数调用，只要新的函数名称能够更好昭示代码意图，就应该提炼）。

（2）将提炼出的代码从源函数复制到目标函数。

（3）检查提炼出的代码，看是否引用了“作用域限于源函数”的变量（包括局部变量和源函数参数）。

（4）检查是否有“仅用于被提炼代码段”的临时变量，如果有，在目标函数中将它们声明为临时变量。

（5）检查提炼代码段，看是否有任何局部变量的值被它改变。（疑问1：这里不太理解，是指提炼代码改变了源函数的局部变量值么？）

（6）将被提炼代码段中需要读取的局部变量，当做参数传给目标函数。

（7）处理完所有局部变量后，再进行编译。

（8）源函数中，将被提炼代码段替换为对目标函数的调用。

（9）编译，测试。

4.小结：

（1）将能提出的尽量都提出来。

（2）提出的代码如果希望返回两个值，就挑选另一块代码来提炼，最好让每个函数只有一个返回值。

 

Inline Method（内联函数）

1.概念：一个函数的本体与名称同样通俗易懂。于是在函数调用点插入函数本体，然后移除该函数。

举个例子，原函数：

public class ExtractMethod {
    int number = 6;

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

    private boolean moreThanFiveLateDeliveries() {
        return number > 5;
    }
}

重构后函数：

public class ExtractMethod {
    int number = 6;

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

2.动机：

（1）当遇到其内部代码与函数名称同样清晰易读，即去掉这种无用的间接层，留下有用的间接层。

（2）当你手上有一群组织不甚合理的函数，就可以先将它们内联到一个大型函数，然后再提炼出合理地小型函数。

 3.做法：

（1）检查函数，确定它不具有多态性（如果有子类继承了这个函数，就不要将这个函数内敛，不然子类无法覆写一个不存在的函数）。

（2）找出这个函数所有的被调用点。

（3）将这个函数所有的被调用点都替换为函数本体。

（4）编译，测试。

（5）删除该函数的定义。

 

Inline Temp（内联临时变量）

1.概念：

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

//改前
BigDecimal applePrice = getPrice().multiply(BigDecimal.valueOf(100L));
return (applePrice > 100);

//改后
return (getPrice().multiply(BigDecimal.valueOf(100L)) > 100);

2.动机：

如果一个临时变量妨碍了其他重构手法，就应该将它内联化。

3.做法：

（1）检查给临时变量赋值的语句，确保等号右边的表达式没有副作用。

（2）如果这个临时变量未被声明为final，则先声明为final，然后编译（通过看是否能编译通过，来确认这个临时变量只被赋值过一次）。

（3）找到该临时变量的所有引用点，将它们替换为“为临时变量赋值”的表达式。

（4）每次修改后，编译并测试。

（5）修改完所有引用点后，删除该临时变量的声明和赋值语句。

（6）编译，测试。

 

Replace Temp with Query（以查询取代临时变量）

1.概念：

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

//改前
double applePrice = getPrice() * basePrice;
if (applePrice > 100) {
    return applePrice * 0.95;
} else {
    return applePrice * 0.98
}

//改后
if  (applePrice() > 100) {
    return applePrice * 0.95;
} else {
    return applePrice * 0.98
}

private double applePrice() {
    getPrice() * basePrice;
}

2.动机：

  2.1临时变量问题在于：

（1）是暂时的，只能在函数内使用

（2）可能会写出很长的函数表达式

  2.2改成函数后：

（1）可供其他函数调用

（2）使代码可读性强

3.做法：

用例子看：

//原始代码
public double getPrice() {
    int basePrice = quantity * itemPrice;
    double discountFactor;
    if (basePrice > 1000) {
        discountFactor = 0.95;
    } else {
        discountFactor = 0.98;
    }
    return basePrice * discountFactor;
}

（1）找出赋值一次的临时变量，然后先用final去定义它们，去检查是否真的只被赋值了一次，如果编译出错说明不止被赋值了一次，就不该进行这项重构：

public double getPrice() {final int basePrice = quantity * itemPrice;
    final double discountFactor;
    if (basePrice > 1000) {
        discountFactor = 0.95;
    } else {
        discountFactor = 0.98;
    }
    return basePrice * discountFactor;
}

（2）每次提取一个临时变量的函数，编译通过后再进行下一个：

public double getPrice() {
    final int basePrice = getBasePrice();
    final double discountFactor;
    if (basePrice > 1000) {
        discountFactor = 0.95;
    } else {
        discountFactor = 0.98;
    }
    return basePrice * discountFactor;
}

private int getBasePrice() {
    return quantity * itemPrice;
}

（3）编译测试完后，再依次替换所有的引用：

public double getPrice() {
    final int basePrice = getBasePrice();
    final double discountFactor;
    if (getBasePrice() > 1000) {
        discountFactor = 0.95;
    } else {
        discountFactor = 0.98;
    }
    return getBasePrice() * discountFactor;
}

private int getBasePrice() {
    return quantity * itemPrice;
}

（4）然后再提炼下一个临时变量：

public double getPrice() {
    final int basePrice = getBasePrice();
    final double discountFactor = getDiscountFactor;
    return getBasePrice() * discountFactor;
}

private int getBasePrice() {
    return quantity * itemPrice;
}

private double getDiscountFactor() {
    if (getBasePrice() > 1000) {
        discountFactor = 0.95;
    } else {
        discountFactor = 0.98;
    }
}

（5）删去final定义的变量，最后再进行一次编译测试：

public double getPrice() {
    return getBasePrice() * getDiscountFactor();
}

private int getBasePrice() {
    return quantity * itemPrice;
}

private double getDiscountFactor() {
    if (getBasePrice() > 1000) {
        discountFactor = 0.95;
    } else {
        discountFactor = 0.98;
    }
}

 

Introduce Explaining Variable（引入解释性变量）

1.概念：

有一个复杂的表达式，将该复杂表达式的结果放进一个临时变量，以此表达式名称解释表达式用途。

//改变前
if ((platform.toUpperCase().indexOf("MAC") > -1) && (browser.toUpperCase().indexOf("IE") > -1) && wasInitialized && resize > 0) {
    //do something
}

//改变后

final boolean isMacOs = platform.toUpperCase.indexOf("MAX") > -1;
final boolean isIEBrowser = browser.toUpperCase.indexOf("IE") > -1;
final boolean wasResized = resize > 0;
if (isMacOs && isIEBrowser && wasInitialized() && wasResized) {
//do something
}

2.动机：

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

3.做法：

//改之前
public double privce() {
    //price is base price - quantity discount + shipping
    return quantity * itemPrice - Math.max(0, quantity - 500) * itemPrice * 0.05 + Math.min(quantity * itemPrice * 0.1, 100.0);
}

（1）声明一个final临时变量，将待分解表达式中一部分的运算当做结果赋值给它，并替换临时变量：

public double privce() {
    //price is base price - quantity discount + shipping
    final double basePrice = quantity * itemPrice;
    return basePrice - Math.max(0, quantity - 500) * itemPrice * 0.05 + Math.min(quantity * itemPrice * 0.1, 100.0);
}

（2）依次提出：

public double privce() {
    //price is base price - quantity discount + shipping
    final double basePrice = quantity * itemPrice;
    final double quantityDiscount = Math.max(0, quantity - 500) * itemPrice * 0.05;
    final double shipping = Math.min(quantity * itemPrice * 0.1, 100.0);
    return basePrice - quantityDiscount + shipping;
}

（*）运用提炼函数来试着处理：

public double privce() {
    return getBasePrice() - getQuantityDiscount() + getShipping();
}

private double getBasePrice() {
    return quantity * itemPrice;
}

private double getQuantityDiscount() {
    return Math.max(0, quantity - 500) * itemPrice * 0.05;
}

private double getShipping() {
    return Math.min(quantity * itemPrice * 0.1, 100.0);
}

问：到底什么时候用引入解释性变量的方式，什么时候用提炼函数的方式呢？

答：该重构方法主要是在提炼函数需要花费更大工作量时才使用。比如你有一个拥有大量局部变量的算法，那么使用提炼函数绝非易事。这时候就可以使用本文的方法来整理代码，然后再考虑下一步

怎么办；一旦搞清楚代码逻辑后，就可以运用以查询取代临时变量把中间引入的那些临时变量去掉。我想你会比较喜欢提炼函数，因为对于同一对象的任何部分，都可以根据自己的需要取用这些提炼

出来的函数。一开始会把这些新函数声明为private；如果其它对象也需要它们，就可以轻易释放这些函数的访问控制。

 

Split Temporary Variable（分解临时变量）

1.概念：

你的程序有某个临时变量被赋值超过一次，它既不是循环变量，也不被利用于搜集计算结果。针对每次赋值，创造一个独立的，对应的临时变量。

//原始代码
double temp = 2 * (height + weight);
log.info("temp:{}", temp);
temp = height * width;
log.info("temp:{}", temp);

//改后
final double perimeter = 2 * (height + weight);
log.info("perimeter:{}", perimeter);
final double area = height * width;
log.info("area:{}", area);

2.动机：

当一个临时变量被赋值多次，就意味着它承担了一个以上的职责，就会降低可读性，因此就应该被替换成多个临时变量。

3.做法：

//改变前，可以看出acc被赋值两次
public double getDistanceTravelled(int time) {
    double result;
    double acc = primaryForce / mass;
    int primaryTime = Math.min(time, delay);
    result = 0.5 * acc * primaryTime * primaryTime;
    int secondaryTime = time - delay;
    if (secondaryTime > 0) {
        double primaryVel = acc * delay;
        acc = (primaryForce + secondaryForce) / mass;
        result += primaryVel * secondaryTime + 0.5 * acc * secondaryTime * secondaryTime;
    }
    return result;
}

（1）将赋值两次的变量依次替换：

public double getDistanceTravelled(int time) {
    double result;
    final double primaryAcc = primaryForce / mass;
    int primaryTime = Math.min(time, delay);
    result = 0.5 * primaryAcc * primaryTime * primaryTime;
    int secondaryTime = time - delay;
    if (secondaryTime > 0) {
        double primaryVel = primaryAcc * delay;
        final double secondaryAcc = (primaryForce + secondaryForce) / mass;
        result += primaryVel * secondaryTime + 0.5 * secondaryAcc * secondaryTime * secondaryTime;
    }
    return result;
}

（2）然后再用其他手法进行重构

 

Remove Assignments to Paramenters（移除对参数的赋值）

1.概念：

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

//修改前
public int discount(int inputVal, int quantity, int yearToDate) {
    if (inputVal > 50) {
        inputVal -= 2;
    }
}

//修改后
public int discount(int inputVal, int quantity, int yearToDate) {
    int result = inputVal;
    if (inputVal > 50) {
        result -= 2;
    }
}

2.动机：

如例子所示，代码中改变了传入参数inputVal的值，降低了代码清晰度，混用了按值传递和按引用传递这两种参数传递方式。

3.做法：

（1）新建一个临时变量，把待处理的参数值附给它。

（2）然后将代码后面所有对参数的引用替换为对新建临时变量的引用。

（3）修改赋值语句，使其改为对新建临时变量的赋值。

（4）编译，测试。

（ps：较长函数中可以使用final来看引用的次数，提高代码清晰度，但在短的或者看起来很清楚的代码中，没有必要用）

 

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

1.概念：

当有一个大型函数，其中对局部变量的使用使你无法采取提炼函数，于是将这个函数放进单独对象中，如此一来局部变量就成了对象内的字段，然后你可以在同一个对象中将这个大型函数分解为多个小型函数。 

2.动机：

当一个函数中局部变量泛滥，想分解这个函数是非常困难的，那么使用以函数对象取代函数这个方法，可以减轻这个负担。它会将所有局部变量都变成函数对象的字段，然后就能对新对象通过提炼函数创造新的函数，从而将原本的大型函数拆解变短。

3.做法：

原函数：

class Account{
    int gamm(int value, int quantity, int year2Date){
        int importValue1 = (value * quantity) + delta();
        int importValue2 = (value * year2Date) + 200;
        if(year2Date - importValue1 >200)
            importValue2-=50;
        int importValue3 = importValue2 * 8;
        //......            
        return importValue3 - 2 * importValue1;
    }
}

（1）建立一个新类，根据待处理函数用途，为这个类命名。

class Gamm{}

（2）在新类中建立final字段，用以保存原先大型函数所在的对象。将这个字段称为源对象，在新类中把原函数的临时变量和参数字段一一对应过来。

class Gamm{
    private final Account _account;
    private int value;
    private int quantity;
    private int year2Date;
    private int importValue1;
    private int importValue2;
    private int importValue3;
....
}

（3）在新类中创建一个构造函数，接收源对象及原函数的所有参数作为参数。

class Gamm{
    private final Account _account;
    private int value;
    private int quantity;
    private int year2Date;
    private int importValue1;
    private int importValue2;
    private int importValue3;

    Gamm(Account source, int inputVal, int quantity, int year2Date){
        this._account = source;
        this.value = inputVal;
        this.quantity = quantity;
        this.year2Date = year2Date;
    }
}

（4）在新类中建立一个compute()函数。

（5）将原函数的代码复制到compute()函数中，如果需要调用原函数的任何函数，请通过源对象字段调用。

int compute(){
    importValue1 = (value * quantity) + _account.delta();
    importValue2 = (value * year2Date) + 200;
    if(year2Date - importValue1 >200)
        importValue2-=50;
    importValue3 = importValue2 * 8;
    //.....        
    return importValue3 - 2 * importValue1;
}

（6）编译

（7）将旧函数的函数本体替换成这样一句话，创建上述新类的一个新对象，而后调用其中的compute()函数。

int gamm(int value, int quantity, int year2Date){
    return new Gamm(this,value,quantity,year2Date).compute();
}

int compute(){
    importValue1 = (value * quantity) + _account.delta();
    importValue2 = (value * year2Date) + 200;
    importantThing();
    importValue3 = importValue2 * 8;
    //.....    
    return importValue3 - 2 * importValue1;
} 
private void importantThing() {
    if(year2Date - importValue1 >200)
        importValue2-=50;
}

小结：将大型函数中，或者变量特别多的函数，将它们拆分成小的函数，可以轻松地对compute()函数采取提炼函数，且不必担心参数传递的问题。

 

Substitute Algorithm（替换算法）

1.概念：你想要把某个算法替换为另一个更加清晰的算法，即将函数本体替换成另一个算法。

//改变前
public String foundPerson(String[] people) {
     for (int i = 0; i < people.length; i++) {
         if (people[i].equalsIgnoreCase("Don")) {
             return "Don";
         }
         if (people[i].equalsIgnoreCase("John")) {
             return "John";
         }
         if (people[i].equalsIgnoreCase("Kent")) {
             return "Kent";
         }
    }
    return " ";
}

//改变后
public String foundPerson(String[] people) {
        List candidates = Arrays.asList(new String[]{"Dom", "John", "Kent"});
        for (int i = 0; i < people.length; i++) {
            if (candidates.contains(people[i])) {
                return people[i];
            }
        }
        return " ";
    }

 

小结

在满足一定情况下：

1.函数过长则重构，重构想到提炼函数的方法（提炼函数）。

2.直接用方法本身（内联函数）。

3.用自身表达式替换当前引用（内敛临时变量，如直接return）。

4.用方法替换某一表达式（以查询取代临时变量）

5.将复杂表达式放进临时变量（引入解释性变量）

6.将一个赋值多次的临时变量替换成不同的变量（分解临时变量）

7.传入参数要赋值，就用另一个临时变量代替（移除对参数的赋值）

8.大型函数局部变量泛滥，将这部分单独拆出去（以函数对象取代函数）

9.将看起来不太聪明的算法替换成看起来简洁干净的算法（替换算法）