摘要：函數(shù)重構(gòu)重構(gòu)有很大一部分都是在重構(gòu)函數(shù)。這條也要具體情況具體使用函數(shù)對象取代函數(shù)函數(shù)對象代替函數(shù)大函數(shù)變成類你有一個大型函數(shù)，其中對局部變量的使用使你無法采用提煉函數(shù)。將這個大型函數(shù)放進一個多帶帶對象中，如此一來局部變量就成了對象內(nèi)的字段。

重構(gòu)有很大一部分都是在重構(gòu)函數(shù)。尤其是長函數(shù)。這是問題的根源。以下是重構(gòu)方法

提煉函數(shù)：（由復雜的函數(shù)提煉出獨立的函數(shù)或者說大函數(shù)分解成由小函數(shù)組成）你有一段代碼可以被組織在一起并獨立出來。將這段代碼放進一個獨立函數(shù)，并讓函數(shù)名稱解釋該函數(shù)的用途。

重構(gòu)前

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());   
}  

重構(gòu)后

                                           
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);   
}

內(nèi)聯(lián)函數(shù)：(直接使用函數(shù)體代替函數(shù)調(diào)用 ) 一個函數(shù)調(diào)用的本體與名稱同樣清楚易懂。在函數(shù)調(diào)用點插入函數(shù)體，然后移除該函數(shù)
重構(gòu)前

int getRating() {  
    return moreThanfiveLateDeliverise() ? 2 : 1;  
}  
bool moreThanfiveLateDeliverise() {  
    return _numberOfLateLiveries > 5;  
}  

                                                       

重構(gòu)后

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

內(nèi)聯(lián)臨時變量：（表達式代替臨時變量）你有一個臨時變量，只被一個簡單表達式賦值一次，而它妨礙了其他重構(gòu)手法。將所有對該變量的引用動作，替換為對它賦值的那個表達式自身
重構(gòu)前

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

                                                  

重構(gòu)后

return （anOrder.BasePrice() >1000);

以查詢代替臨時變量：（獨立函數(shù)代替表達式）你的程序以一個臨時變量保存某一個表達式的運算效果。將這個表達式提煉到一個獨立函數(shù)中。將這個臨時變量的所有引用點替換為對新函數(shù)的調(diào)用。此后，新函數(shù)就可以被其他函數(shù)調(diào)用。

重構(gòu)前

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

重構(gòu)后

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

注：這一條我始終不覺得合理。如果從性能上看。明顯重構(gòu)前的性能會比第二種更好。而且更容易理解

引入解釋性變量：（復雜表達式分解為臨時解釋性變量）你有一個復雜的表達式。將該復雜表達式（或其中一部分）的結(jié)果放進一個臨時變量，以此變量名稱來解釋表達式用途。
重構(gòu)前

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

重構(gòu)后
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  

}
注：這一條和上上條并沒有沖突。上上條指的是單純地取值函數(shù)，如get方法。這一條針對無法理解的方法鏈

分解臨時變量：（臨時變量不應(yīng)該被賦值超過一次）你的程序有某個臨時變量被賦值超過一次，它既不是循環(huán)變量，也不被用于收集計算結(jié)果。針對每次賦值，創(chuàng)造一個獨立、對應(yīng)的臨時變量
重構(gòu)前

double temp = 2 + (_height + _width);  
Console.WriteLine(temp);  
temp = _height * _width;  
Console.WriteLine(temp);  

                                                        

重構(gòu)后

const double perimeter = 2 + (_height + _width);  
Console.WriteLine(perimeter);  
const double area = _height * _width;  
Console.WriteLine(area);

 

移除對參數(shù)的賦值：（不要對參數(shù)賦值）代碼對一個 參數(shù)賦值。以一個臨時變量取代該參數(shù)的位置。
重構(gòu)前

int discount (int inputVal, int quantity, int yearToDate){   
    if (inputVal > 50) inputVal -= 2;   
}  
     

重構(gòu)后

int discount (int inputVal, int quantity, int yearToDate) {   
     int result = inputVal;   
     if (inputVal > 50) result -= 2;   
}  

注：如果傳的是對象。除非你想要操作對象。否則就留下了bug的風險。因為對象傳入方法被改變了。（這條也要具體情況具體使用）

函數(shù)對象代替函數(shù)：（大函數(shù)變成類）你有一個大型函數(shù)，其中對局部變量的使用使你無法采用 Extract Method （提煉函數(shù)）。將這個大型函數(shù)放進一個多帶帶對象中，如此一來局部變量就成了對象內(nèi)的字段。然后你可以在同一個對象中將這個大型函數(shù)分解為多個小型函數(shù)。
重構(gòu)前

class Order...  
double price() {   
    double primaryBasePrice;  
    double secondaryBasePrice;   
    double tertiaryBasePrice;   
    // long computation; ...   
}   

重構(gòu)后

 class Price {   
        double primaryBasePrice;  
        double secondaryBasePrice;   
        double tertiaryBasePrice;   
        public void price(){
        // long computation; ...   
   

或者可以采用static method

替換算法：（函數(shù)本體替換為另一個算法）你想要把某個算法替換為另一個更清晰地算法。將函數(shù)本體替換為另一個算法。
重構(gòu)前

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 "";   
}
                                            

重構(gòu)后

String foundPerson(String[] people){   
    List candidates   
             = Arrays.asList(new String[] {"Don",   "John", "Kent"});   
    for (int i=0; i
注：如果可以使用更簡單并清晰的方式。就果斷換方式