重构-改善既有代码的设计(六)--重新组织函数

摘要：函数重构重构有很大一部分都是在重构函数。这条也要具体情况具体使用函数对象取代函数函数对象代替函数大函数变成类你有一个大型函数，其中对局部变量的使用使你无法采用提炼函数。将这个大型函数放进一个多带带对象中，如此一来局部变量就成了对象内的字段。

重构有很大一部分都是在重构函数。尤其是长函数。这是问题的根源。以下是重构方法

提炼函数：（由复杂的函数提炼出独立的函数或者说大函数分解成由小函数组成）你有一段代码可以被组织在一起并独立出来。将这段代码放进一个独立函数，并让函数名称解释该函数的用途。

重构前

</>复制代码 
void printOwing() {   
    //print banner  
    System.out.println(“*********”);  
    System.out.println(“Banner”);  
    System.out.println(“*********”);  
    //print details  
    System.out.println ("name: " + _name);   
        System.out.println ("amount " + getOutstanding());   
}  

重构后

</>复制代码 
                                           
void printOwing()  {  
    printBanner();   
    printDetails(getOutstanding());   
}   
  
Void printBanner()  {  
    //print banner  
    System.out.println(“*********”);  
    System.out.println(“Banner”);  
    System.out.println(“*********”);  
}  
void printDetails (double outstanding)   {   
    System.out.println ("name: " + _name);   
    System.out.println ("amount " + outstanding);   
}

内联函数：(直接使用函数体代替函数调用 ) 一个函数调用的本体与名称同样清楚易懂。在函数调用点插入函数体，然后移除该函数
重构前

</>复制代码 
int getRating() {  
    return moreThanfiveLateDeliverise() ? 2 : 1;  
}  
bool moreThanfiveLateDeliverise() {  
    return _numberOfLateLiveries > 5;  
}  
                                                       

重构后

</>复制代码 
int getRating(){  
     return _numberOfLateLiveries > 5 ? 2 : 1;  
}  

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

</>复制代码 
double basePrice = anOrder.BasePrice();  
return basePrice(>1000);  
     
                                                  

重构后

</>复制代码 
return （anOrder.BasePrice() >1000);

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

重构前

</>复制代码 
double basePrice = _quantity*_itemPrice;  
if (basePrice > 1000) {  
    return basePrice * 0.95;  
else   
    return basePrice * 0.98;  
                                                         

重构后

</>复制代码 
if (basePrice() > 1000)  
    return basePrice() * 0.95;   
else   
    return basePrice() * 0.98;   
……  
double basePrice() {   
    return _quantity * _itemPrice;   
}    

注：这一条我始终不觉得合理。如果从性能上看。明显重构前的性能会比第二种更好。而且更容易理解

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

</>复制代码 
if (Platform.ToUpperCass().indexOf("MAC") > -1 && (Browser.ToUpperCass().indexOf("Ie") > -1) && WasInitalized() ) {  
    //do something  
 }  

重构后
const bool imMacOs = Platform.ToUpperCass().indexOf("MAC") > -1;
const bool isIeBrowser = Browser.ToUpperCass().indexOf("Ie") > -1;
const bool wasInitalized = WasInitalized();
if (imMacOs && isIeBrowser && wasInitalized)
{

</>复制代码 
//do something  

}
注：这一条和上上条并没有冲突。上上条指的是单纯地取值函数，如get方法。这一条针对无法理解的方法链

分解临时变量：（临时变量不应该被赋值超过一次）你的程序有某个临时变量被赋值超过一次，它既不是循环变量，也不被用于收集计算结果。针对每次赋值，创造一个独立、对应的临时变量
重构前

</>复制代码 
double temp = 2 + (_height + _width);  
Console.WriteLine(temp);  
temp = _height * _width;  
Console.WriteLine(temp);  
                                                        

重构后

</>复制代码 
const double perimeter = 2 + (_height + _width);  
Console.WriteLine(perimeter);  
const double area = _height * _width;  
Console.WriteLine(area);
 

移除对参数的赋值：（不要对参数赋值）代码对一个 参数赋值。以一个临时变量取代该参数的位置。
重构前

</>复制代码 
int discount (int inputVal, int quantity, int yearToDate){   
    if (inputVal > 50) inputVal -= 2;   
}  
     

重构后

</>复制代码 
int discount (int inputVal, int quantity, int yearToDate) {   
     int result = inputVal;   
     if (inputVal > 50) result -= 2;   
}  

注：如果传的是对象。除非你想要操作对象。否则就留下了bug的风险。因为对象传入方法被改变了。（这条也要具体情况具体使用）

函数对象代替函数：（大函数变成类）你有一个大型函数，其中对局部变量的使用使你无法采用 Extract Method （提炼函数）。将这个大型函数放进一个多带带对象中，如此一来局部变量就成了对象内的字段。然后你可以在同一个对象中将这个大型函数分解为多个小型函数。
重构前

</>复制代码 
class Order...  
double price() {   
    double primaryBasePrice;  
    double secondaryBasePrice;   
    double tertiaryBasePrice;   
    // long computation; ...   
}   

重构后

</>复制代码 
 class Price {   
        double primaryBasePrice;  
        double secondaryBasePrice;   
        double tertiaryBasePrice;   
        public void price(){
        // long computation; ...   
   
或者可以采用static method

替换算法：（函数本体替换为另一个算法）你想要把某个算法替换为另一个更清晰地算法。将函数本体替换为另一个算法。
重构前

</>复制代码 
String foundPerson(String[] people){   
    for (int i = 0; i < people.length; i++)  {   
        if (people[i].equals ("Don")){  
             return "Don";   
         }  
         if (people[i].equals ("John")) {  
           return "John";   
         }   
         if (people[i].equals ("Kent")){   
                return "Kent";   
         }   
     }  
     return "";   
}
                                            

重构后

</>复制代码 
String foundPerson(String[] people){   
    List candidates   
             = Arrays.asList(new String[] {"Don",   "John", "Kent"});   
    for (int i=0; i
注：如果可以使用更简单并清晰的方式。就果断换方式