一.重構(gòu)原則

1.何謂重構(gòu)

對軟件內(nèi)部結(jié)構(gòu)的一種調(diào)整，目的是在不改變軟件可觀察行為的前提下，提高其可理解性，降低其修改成本。

另一種解釋是：使用一系列重構(gòu)手法，在不改變軟件可觀察行為的前提下，調(diào)整其結(jié)構(gòu)。

重構(gòu)不止是代碼整理，它提供了一種高效且受控的代碼整理技術(shù)

2.為何重構(gòu)

改進(jìn)軟件設(shè)計：如果沒有重構(gòu)，程序的設(shè)計會逐漸變質(zhì)，重構(gòu)很像是在整理代碼，你所做的就是讓所有的東西回到應(yīng)處的位置上。幫助找到bug：對代碼進(jìn)行重構(gòu)，可以深入理解代碼的作為，在搞清楚程序結(jié)構(gòu)的同時，想不把bug揪出來都難。提高編程速度：良好的設(shè)計是快速開發(fā)的根本，改善設(shè)計、提高可讀性，減少錯誤，這些都是提高質(zhì)量。

3.何時重構(gòu)

任何情況下我都反對專門撥出時間進(jìn)行重構(gòu)。重構(gòu)本來就不是一件應(yīng)該特別撥出時間做的事情，重構(gòu)應(yīng)該隨時隨地的進(jìn)行。

三次法則：第一次做某件事情是只管去做；第二次做類似的事情會產(chǎn)生反感；第三次再做類似的事，你就應(yīng)該重構(gòu)

最常見的重構(gòu)時機(jī)是想給軟件添加新特性的時候；

重構(gòu)的另個一原動力是：代碼的設(shè)計無法幫助我輕松的添加所需要的特性

• 修改錯誤的時候
• review代碼的時重構(gòu)

間接層和重構(gòu)

計算機(jī)科學(xué)是這樣一門科學(xué)：它相信所有的問題都可以通過增加一個間接層來解決。

大多數(shù)重構(gòu)都為程序引入了更多的間接層，重構(gòu)往往把大型的對象拆成多個小型的對象，把大型的函數(shù)拆成多個小型的函數(shù)。

但是，間接層是一把雙刃劍。每次把一個東西分成兩份，你就需要多管理一個東西。如果某個對象委托另一個對象，后者又委托另一個對象，程序會愈加難以閱讀。

何時不該重構(gòu)：有時候既有代碼實在太混亂，重構(gòu)它還不如重新寫一個來得簡單。

重寫而非重構(gòu)的一個清楚訊號是：現(xiàn)有代碼根本不能正常運(yùn)作。

二.代碼的壞味道

1.重復(fù)代碼

如果你在一個以上的地點(diǎn)看到相同的程序結(jié)構(gòu)，那么可以肯定：設(shè)法將它們合二為一，程序會變得更好 。

• 同一個類中有相同的表達(dá)式：提煉出重復(fù)的代碼，然后讓兩個地方都調(diào)用被提煉出來的那一段代碼；
• 兩個互為兄弟的子類內(nèi)含有相同的表達(dá)式：提煉出相同代碼，將它推入超類內(nèi)；
• 兩個毫不相干的類中出現(xiàn)：將重復(fù)的代碼提煉到一個獨(dú)立的類中。

2.過長的類

擁有短函數(shù)的對象活得比較好、比較長。間接層所能帶來的全部利益——解釋能力、共享能力、選擇能力——都是由小型函數(shù)支持的。

每當(dāng)感覺需要以注釋來說明點(diǎn)什么的時候，我們就把需要說明的東西寫進(jìn)一個獨(dú)立的函數(shù)中。

如何確定提煉哪一段代碼？尋找注釋是一個很好的技巧。它們通常能指出代碼用途和實現(xiàn)手法之間的語義距離。如果代碼前方有一行注釋，就是提醒你：可以將這段代碼替換成一個函數(shù)。

條件表達(dá)式和循環(huán)常常也是提煉的信號。

3.過大的類

如果想利用單個類做太多的事情，其內(nèi)往往就會出現(xiàn)太多實力變量。

類內(nèi)如果有太多代碼，也是代碼重復(fù)、混亂病最終走向死亡的源頭。

4.過長參數(shù)列

太長的參數(shù)列難以理解，太多的參數(shù)會造成前后不一致、不容易使用，而且一旦你需要更多數(shù)據(jù)，就不得不修改它。如果將對象傳遞給函數(shù)，大多數(shù)修改都將沒有必要。

5.發(fā)散式變化

如果某個類經(jīng)常因為不同的原因在不同的方向上發(fā)生變化，那么此時也許將這個對象分成兩個會更好，這么一來每個對象就可以只因為一種變化而需要修改。

6.散彈式修改

如果每遇到某種變化，你都必須在許多不同的類內(nèi)做出許多小修改，你所面臨的壞味道就是散彈式修改。如果需要修改的代碼散布四處，你不但很難找到它們，也很容易忘記某個重要的修改。

把所有需要修改的代碼放進(jìn)同一個類中，如果眼下沒有合適的類可以安置這些代碼就創(chuàng)造一個。

7.依戀情結(jié)

對象技術(shù)的要點(diǎn)在于：將數(shù)據(jù)和對數(shù)據(jù)的操作行為包裝在一起

有一種經(jīng)典的氣味是：函數(shù)對某個類的興趣高過對自己所處類的興趣。某個函數(shù)為了計算某個值，從另一個對象那調(diào)用幾乎半打的取值函數(shù)。

一個函數(shù)往往會用到幾個類的功能，那么它該置于何處？我們的原則是：判斷哪個類擁有最大被此函數(shù)使用的數(shù)據(jù)，然后就把這個函數(shù)和那些數(shù)據(jù)放在一起。

8.數(shù)據(jù)泥團(tuán)

很多地方看到相同的三四項數(shù)據(jù)一起出現(xiàn)。這些總是綁在一起出現(xiàn)的數(shù)據(jù)應(yīng)該擁有屬于他們自己的對象。

首先找到這些數(shù)據(jù)以字段形式出現(xiàn)的地方，將它們提煉到一個獨(dú)立的對象中。這么做的直接好處是可以將很多參數(shù)列縮短簡化函數(shù)調(diào)用。

9.基本類型偏執(zhí)

對象的一個極大價值在于：它們模糊了橫旦與基本數(shù)據(jù)和體積較大的類之間的界限

對象技術(shù)的新手通常不愿意在小任務(wù)上運(yùn)用小對象——結(jié)合數(shù)值和比重的money類、有一個起始值和一個結(jié)束值組成的range類。將原本單獨(dú)存在的數(shù)值替換成對象，從而走出傳統(tǒng)的洞窟，進(jìn)入炙手可熱的對象世界。

10.switch驚悚現(xiàn)身

面向?qū)ο蟮囊粋€最明顯的特征是：少用switch語句

一看到switch語句，就應(yīng)該考慮以多態(tài)來替換它。

如果只是在單一函數(shù)中有些選擇實例，且并不想改動它們，那么多態(tài)就有點(diǎn)殺雞用牛刀了。

11.平行集成體系

每當(dāng)你為某個類增加一個子類，必須也為另一個類相應(yīng)增加一個子類。

消除這種重復(fù)性的一般策略是：讓一個繼承體系的實例引用另一個繼承體系的實例。

12.冗余類

某個類原本對得起自己的身價，但重構(gòu)使它身形縮水，不再做那么多工作，這個時候請讓這個類莊嚴(yán)赴義吧。

13.夸夸其談未來性

企圖以各種各樣的鉤子和特殊情況來處理一些非必要的事情，這種懷味道就出現(xiàn)了。如果用到了那就值得去做，如果用不到那就不值得，只會擋你的路，所以把它挪開吧。

如果你的某個抽象類其實沒有起到太大的作用，函數(shù)上的某些參數(shù)未被使用...可以移除它們了。

14.令人迷惑的暫時字段

某個實例變量僅為某種特定的情況而設(shè)。這樣的代碼讓人不易理解。在變量未被使用的情況下猜測當(dāng)初其設(shè)置目的，會讓你發(fā)瘋的。

15.過度耦合消息鏈

如果你看到用戶向一個對象請求另一個對象，然后再向后者請求另一個對象，然后再請求另個一對象........這就是消息鏈。采用這種方式，意味著客戶代碼將與查找過程中的導(dǎo)航結(jié)構(gòu)緊密耦合。一旦對象間的關(guān)系發(fā)生任何變化，客戶端就不得不做出相應(yīng)的修改。

16.中間人

封裝往往伴隨著委托。你也許會看到某個類接口有一半的函數(shù)都委托給其他類，這樣就是過度運(yùn)用。

17.狎昵關(guān)系

有時會看到兩個類過于親密，話費(fèi)太多的時間去探究彼此的private成分。過分狎昵的類必須拆散，幫它們劃清界線，從而減少狎昵行徑。

繼承往往造成過度親密，因為子類對超類的了解總是超過后者的主觀愿望。如果你覺得該讓孩子獨(dú)立生活了，讓他離開繼承。

18/異曲同工的類

兩個函數(shù)做同一件事，卻有著不同的簽名。

19.不完美的類庫

類庫函數(shù)構(gòu)造的不夠好，又不能修改它們：

• 如果只想修改類的一兩個函數(shù)，可以引入外加函數(shù)。

• 如果想要添加一大堆額外行為，建立一個新類包含這些額外行為，讓其成為子類。

20.純稚的數(shù)據(jù)類

純稚的數(shù)據(jù)類是指：它們擁有一些字段，以及用于訪問（讀寫）這些字段的函數(shù)，除此之外一無長物。

• 封裝public字段;

• 恰當(dāng)封裝容器類字段;

• 移除不應(yīng)修改的字段的設(shè)置函數(shù);

• 提煉調(diào)用函數(shù)以隱藏取值/設(shè)值函數(shù);

21.被拒絕的遺贈

子類只運(yùn)用了父類的一部分函數(shù)和數(shù)據(jù)。為子類建立一個兄弟類,將所有用不到的字段/函數(shù)下移至兄弟類,保證超類的純粹;

22.過多的注釋

注釋之所以存在是因為代碼很糟糕 。注釋的最高境界——代碼即注釋。

當(dāng)你感覺需要撰寫注釋時，請先嘗試重構(gòu)，試著讓所有的注釋都變得多余。

三.重新組織函數(shù)

1.提煉函數(shù)

動機(jī)：看到一個過長的函數(shù)或者一段需要注釋才能讓人理解用途的代碼，將這段代碼放一個獨(dú)立的函數(shù)中；

做法：

• 創(chuàng)造一個新函數(shù)，根據(jù)這個函數(shù)的意圖來命名它；

只要新函數(shù)的名稱能夠以更好的方式昭示代碼意圖，你也應(yīng)該提煉它。但如果想不到一個更有意義的名稱就別動

• 將提煉的代碼從原函數(shù)復(fù)制到新建的目標(biāo)函數(shù)中；

• 將被提煉代碼段中需要讀取的局部變量，當(dāng)作參數(shù)傳遞給目標(biāo)函數(shù)；

• 在原函數(shù)中，將被提煉代碼段替換為目標(biāo)函數(shù)調(diào)用。

2.內(nèi)聯(lián)函數(shù)

一個函數(shù)的本體與名稱同樣清楚易懂。在函數(shù)調(diào)用點(diǎn)插入函數(shù)本體，然后移除該函數(shù)。

動機(jī)：

• 一群組織不甚合理的函數(shù)。你可以將它們都內(nèi)聯(lián)到一個大函數(shù)中，再從中提煉出組織合理的小型函數(shù)。
• 使用的太多的間接層，使得系統(tǒng)中的所有函數(shù)都似乎只是對另一個函數(shù)的簡單委托，造成在委托動作之間暈頭轉(zhuǎn)向。

做法：

• 檢查函數(shù)，確定不具備多態(tài)；

如果子類繼承了這個函數(shù)，就不要將此函數(shù)內(nèi)聯(lián)，因為子類無法復(fù)寫一個根本不存在的函數(shù)。

• 找出這個函數(shù)的所有調(diào)用點(diǎn)；

• 將這個函數(shù)的所有調(diào)用點(diǎn)都替換成函數(shù)本體。

3.內(nèi)聯(lián)臨時變量

有一個臨時變量，只被一個簡單的表達(dá)是賦值一次，而它妨礙了其他重構(gòu)手法。將所有對該變量的引用動作，替換為對它賦值的那個表達(dá)式自身

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

替換為：

return (anOrder.basePrice > 1000);

4.以查詢?nèi)〈R時變量

你的程序以一個臨時變量保存某一表達(dá)式的運(yùn)算結(jié)果。將這個表達(dá)式提煉到一個獨(dú)立的函數(shù)中。將這個臨時變量的所有引用點(diǎn)替換為對新函數(shù)的調(diào)用。此后，新函數(shù)就可被其他函數(shù)使用。

double basePrice = quantity * timePrice;
if(basePrice > 1000){
    return basePrice * 09.5;
} else {
    return basePrice * 0.98;
}

替換為：

if(basePrice() > 1000){
    return basePrice * 09.5;
} else {
    return basePrice * 0.98;
}
double basePrice(){
    return quantity * timePrice;
}

臨時變量只在所屬的函數(shù)中可見，如果把臨時變量替換為一個查詢，那么同一個類中的所有函數(shù)都將可以獲得這個份信息，這將帶給你極大的幫助，使你能夠為這個類編寫更清晰的代碼。

5.引入注釋性變量

你有一個復(fù)雜的表達(dá)式。將該復(fù)雜表達(dá)式（或其中一部分）的結(jié)果放進(jìn)一個臨時變量，以此變量名稱來解釋表達(dá)式用途。

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

替換為：

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

表達(dá)式有可能非常復(fù)雜難以理解。這種情況下，臨時變量可以幫助你將表達(dá)式分解為比較容易管理的形式。

在條件邏輯中，你可以用這項重構(gòu)將每個條件子句提煉出來，以一個良好命名的臨時變量來解釋對應(yīng)條件子句的意義。另一種情況是：在較長的算法中，可以運(yùn)用臨時變量來解釋每一步運(yùn)算的意義。

6.分解臨時變量

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

double temp = 2 * (height + width);
System.out.println(temp);
temp = height * width;
System.out.println(temp);

替換為：

double perimeter = 2 * (height + width);
System.out.println(perimeter);
double area = height * width;
System.out.println(area);

如果臨時變量被賦值超過一次，就意味著它們在函數(shù)中承擔(dān)了一個以上的責(zé)任。如果臨時變量承擔(dān)多個責(zé)任，它就應(yīng)該被替換為多個臨時變量。每個變量只承擔(dān)一個責(zé)任，同一個臨時變量承擔(dān)兩件不同的事情會令代碼閱讀者糊涂

7.移除對參數(shù)的賦值

代碼對一個參數(shù)進(jìn)行復(fù)制。以一個臨時變量取代該參數(shù)的位置。

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

替換為：

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

如果代碼的語義是按引用傳遞的，請在調(diào)用段檢查調(diào)用后是否還使用了這個參數(shù)。

8.替換算法

想要把某個算法替換為另一個更清晰的算法。將函數(shù)本體替換成為另一個算法。

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 < people.length; i++){
        if(candidates.contains(people[i])){
            return prople[i];
        }
    }
    return "";
}

四.在對象之間搬移特性

在對象設(shè)計過程中，決定把責(zé)任放在哪兒是即使不是最重要的事，也是最重要的事之一。常常只使用搬移函數(shù)和搬移字段簡單地移動對象行為，就可以解決這些問題。如果這兩個重構(gòu)手法都需要用到，我會首先使用搬移字段，再使用搬移方法。如果一個類承擔(dān)了太多責(zé)任而變得臃腫不堪，這種情況下會使用提煉類將一部分責(zé)任分離出去。如果一個類變得太不負(fù)責(zé)任，使用將類內(nèi)聯(lián)化將它融入到另一個類中。

1.搬移函數(shù)

你的程序中，有個函數(shù)與其所駐類之外的另個一類進(jìn)行跟過的交流：調(diào)用后者或被后者調(diào)用。在該函數(shù)最長引用的類中建立一個有著類似行為的新函數(shù)。將舊函數(shù)變成一個單純的委托函數(shù)，或者將舊函數(shù)完全移除。

如果一個類有太多行為，或如果一個類與另一個類有太多合作而高度耦合，就需要搬移函數(shù)。可以是系統(tǒng)中的類更簡單

2.搬移字段

程序中，某個字段被其所駐類之外的另一個類更多的用到。在目標(biāo)類新建一個字段，修改原字段的所有用戶，令他們改用新字段。

3、提煉類

某個類做了應(yīng)該由兩個類做的事。建立一個新類，將相關(guān)字段和函數(shù)從就類搬到新類。

4.將類內(nèi)聯(lián)化

某個類沒有做太多的事情，不在承擔(dān)足夠責(zé)任，不再有的那單獨(dú)存在的理由。將這個類的所有特性搬移到另一個類中，然后移除原類。

5.隱藏“委托關(guān)系”

客戶通過一個委托類來調(diào)用另一個對象。在服務(wù)類上建立客戶所需要的所有函數(shù)，用來隱藏委托關(guān)系。

封裝意味每個對象都應(yīng)該少了解系統(tǒng)的其他部分。一旦發(fā)生變化，需要了解這一變化的對象就會比較少。

如果某個客戶先通過服務(wù)對象的字段得到另一個對象，然后調(diào)用后者的函數(shù)。那么客戶就必須知曉這一層委托關(guān)系。萬一委托關(guān)系變化，客戶也要相應(yīng)變化。

6.移除中間人

某個類做了過多的簡單委托。讓客戶直接調(diào)用委托類。每當(dāng)客戶要使用手委托類的新特性時，你就必須在服務(wù)端添加一個簡單委托函數(shù)。隨著受委托類的特性越來越多，這一過程會讓你很痛苦。

7.引入外加函數(shù)

你需要為提供服務(wù)的類增加一個函數(shù)，但你無法修改這個類。在客戶類中建立一個函數(shù)，并以第一參數(shù)形式傳入一個服務(wù)類實例。

 Date newStart = new Date(year, month, date + 1); 

替換為：

Date newStart = nextDay(nowDate);
private static Date nextDay(Date arg){
    retrun new Date(arg.getYear(), arg.getMonth(), arg.getDate() + 1);
}

如果可以修改源碼，你可以自行添加一個新函數(shù)；如果不能，你就得在客戶端編碼，補(bǔ)足你要的那個函數(shù)

8.引入本地擴(kuò)展

你需要為服務(wù)類踢狗一些額外函數(shù)，但你無法修改這個類。建立一個新類，使它包含這些額外函數(shù)。讓這個擴(kuò)展品成為源類的子類或包裝類。

五.重新組織數(shù)據(jù)

1.自封裝字段

直接訪問一個字段。為這個字段建立取值/設(shè)值函數(shù)，并且只以這些函數(shù)來訪問字段。

private int low, high;
boolean includes(int arg){
    retrun arg >= low && arg <= high;
}

替換為：

private int low, high;
boolean includes(int arg){
    retrun arg >= getLow() && arg <= getHigh();
}
int getLow(){
    retrun low;
}
int getHigh(){
    return high;
}

在“字段訪問方式”這個問題上，存在兩種截然不同的觀點(diǎn)：

• 在該變量定義所在的類中，你可以自由的訪問。
• 即使在這個類中你也應(yīng)該只使用訪問函數(shù)間接訪問。間接訪問的好處是：子類可以通過復(fù)寫一個函數(shù)而改變獲取數(shù)據(jù)的途徑；它支持更靈活的數(shù)據(jù)管理方式，例如延遲初始化。

2.以對象取代數(shù)據(jù)值

你有一個數(shù)據(jù)項，需要與其他數(shù)據(jù)和行為一起使用才有意義。將數(shù)據(jù)項變?yōu)閷ο?/code>。一開始你肯能會用一個字符串來表示“電話號碼”概念，但是隨后你會發(fā)現(xiàn)，電話號碼需要“格式化”、“區(qū)號”之類的行為。這時候就需要為帶替換的數(shù)值新建一個類。

3.將值對象改為引用對象

你從一個類衍生出許多彼此相等的實例，希望將它們替換為同一個對象。將這個值對象變成引用對象。

4.將引用對象改為值對象

你有一個引用對象，很小且不可改變，而且不易管理。將它變成一個值對象。

5.以對象取代數(shù)組

你有一個數(shù)組，其中的元素各自代表不同的東西。以對象替換數(shù)組。對于數(shù)組中的每個元素，以一個字段來表示

6.復(fù)制“被監(jiān)視數(shù)據(jù)”

你有一些領(lǐng)域數(shù)據(jù)置身GUI控件中，而領(lǐng)域函數(shù)需要訪問這些數(shù)據(jù)。將該數(shù)據(jù)復(fù)制到一個領(lǐng)域?qū)ο笾小＝⒁粋€Observer模式，用以同步領(lǐng)域?qū)ο蠛虶UI對象內(nèi)的重復(fù)數(shù)據(jù)。

7.將單向關(guān)聯(lián)改為雙向關(guān)聯(lián)

兩個類都需要使用對方特性，但其間只有一條單向連接。添加一個反向指針，并使修改函數(shù)能夠同時更新兩條連接。

8.將雙向關(guān)聯(lián)改為單向關(guān)聯(lián)

兩個類之間有雙向關(guān)聯(lián)，但其中一個類如今不再需要另一個類的特性。去除不必要的關(guān)聯(lián)。

9.以字面常量取代魔數(shù)

你有一個字面數(shù)值，帶有特別含義。創(chuàng)造一個常量，根據(jù)其意義為它命名，并將上述的字面數(shù)值替換為常量。

10.封裝字段

你的類中存在一個public字段。將它聲明為private，并提供相應(yīng)的訪問函數(shù)。

11.封裝集合

有個函數(shù)返回一個集合。讓這個函數(shù)返回該集合的一個只讀副本，并在這個類中提供添加/移除集合元素的函數(shù)。

六.簡化條件表達(dá)式

1.分解條件表達(dá)式

有一復(fù)雜的條件語句。從if、then、else三個段落中分別提煉出獨(dú)立函數(shù)。

2.合并表達(dá)式

你有一系列條件測試，都得到相同結(jié)果。將這些測試合并為一個條件表達(dá)式，并將這個條件表達(dá)式提煉成一個獨(dú)立函數(shù)。

3.合并重復(fù)的條件代碼

在表達(dá)式的每個分支上都執(zhí)行了相同的一段代碼。將這段重復(fù)代碼搬移到條件表達(dá)式之外。

4.移除控制標(biāo)記

在一系列布爾表達(dá)式中,某個變量帶有”控制標(biāo)記”的作用。以break/return語句取代控制標(biāo)記。

5.以多態(tài)取代條件表達(dá)式

有個條件表達(dá)式根據(jù)對象類型的不同而選擇不同的行為。將這個條件表達(dá)式的每個分支放進(jìn)一個子類內(nèi)的覆寫函數(shù)中，然后將原始函數(shù)聲明為抽象函數(shù)。

七.簡化函數(shù)調(diào)用

1.函數(shù)改名

函數(shù)的名稱未能揭示其用途。修改函數(shù)名稱。

2.添加參數(shù)

某個函數(shù)需要從調(diào)用端得到更多信息。為此函數(shù)添加一個對象參數(shù)，讓該對象帶僅函數(shù)所需信息。

3.移除參數(shù)

函數(shù)本體不再需要某個參數(shù)。去除參數(shù)。

4.分離查詢函數(shù)和修改函數(shù)

某個函數(shù)既返回對象狀態(tài)值，又修改對象值。建立兩個不同函數(shù),其中一個負(fù)責(zé)查詢,另一個負(fù)責(zé)修改。

5.令函數(shù)攜帶參數(shù)

若干函數(shù)做了類似的工作，但在函數(shù)本體中包含了不同的值。建立單一函數(shù),以參數(shù)表達(dá)那些不同的值。

有這樣兩個函數(shù)：它們做著類似的工作，但因少數(shù)幾個值致使行為略有不同。在這種情況下，你可以將這些各自分離的函數(shù)同一起來，并通過參數(shù)來處理那些變化情況，用以簡化問題。

6.以明確函數(shù)取代參數(shù)

你有一個函數(shù)，其中完全取決于參數(shù)值而采用不同行為。針對該參數(shù)的每一個可能值，建立一個獨(dú)立函數(shù)。

如果某個參數(shù)有多種可能的值，而函數(shù)內(nèi)又以條件表達(dá)式檢查這些參數(shù)值，并根據(jù)不同參數(shù)值做出不同的行為，那么就應(yīng)該使用本項重構(gòu)。

7.保持對象完整

從某個對象中取出若干值，將它們作為某一次函數(shù)調(diào)用時的參數(shù)。改為傳遞整個對象。

8.以函數(shù)取代參數(shù)

對象調(diào)用某個函數(shù)，并將所得結(jié)果作為參數(shù)，傳遞給另一函數(shù)，而接受該參數(shù)的函數(shù)本身也能夠調(diào)用前一個函數(shù)。讓參數(shù)接受者去除該參數(shù)，直接調(diào)用前一個函數(shù)。

9.引入?yún)?shù)對象

某些參數(shù)總是很自然的同時出現(xiàn)。以一個對象取代這些參數(shù)。

10.移除設(shè)值函數(shù)

類中某個字段在對象創(chuàng)建時被設(shè)值，然后不再改變。去掉該字段的所有設(shè)值函數(shù)。

11.隱藏函數(shù)

某個函數(shù)，從來沒有被其他任何類用到 。將函數(shù)修改為private。

12.以工廠函數(shù)取代構(gòu)造函數(shù)

希望在創(chuàng)建對象時不僅僅是做簡單的建構(gòu)動作 。將構(gòu)造函數(shù)替換為工廠函數(shù)。

八.處理概括關(guān)系

1.字段上移

兩個子類擁有相同的字段。將該字段移至超類。

2.函數(shù)上移

有些函數(shù)在各子類中產(chǎn)生完全相同的結(jié)果。將該函數(shù)移至超類。

3.構(gòu)造函數(shù)本體上移

各個子類中有一些構(gòu)造函數(shù)本體幾乎完全一致 。在超類中新建一個構(gòu)造函數(shù)，并在子類構(gòu)造函數(shù)中調(diào)用它。

4.函數(shù)下移

超類中的某個函數(shù)只與部分(而非全部)子類用到。將函數(shù)移到相關(guān)的子類中。

5.字段下移

超類中的某個字段只被部分(而非全部)子類用到。將字段移到需要它的子類中。

6.提煉子類

類中的某些特性只被某些(而非全部)實例用到。新建一個子類，將上述部分的特性移到子類中。

7.提煉超類

兩個類有相似特性。為這兩個類建立一個超類,將相同特性移至超類。

8.提煉接口

若干客戶使用類接口中的同一子集，或兩個類的接口有部分相同。將相同的子集提煉到一個獨(dú)立接口中。

9.折疊繼承體系

超類和子類之間無太大區(qū)別。將它們合為一體。

10.塑造模板函數(shù)

子類中某些函數(shù)以相同順序執(zhí)行類似操作，但各操作細(xì)節(jié)略有不同。將操作放進(jìn)獨(dú)立函數(shù)(保持簽名相同)，然后將它們移至超類。

11.以委托取代繼承

某個子類只使用超類接口中的一部分或根本不需要繼承而來的數(shù)據(jù)。子類新建字段保存超類，調(diào)整子類函數(shù)為委托超類，取消繼承關(guān)系。

12.以繼承取代委托

你在兩個類中使用委托關(guān)系，并經(jīng)常為整個接口編寫許多極簡單的委托函數(shù)。讓委托類繼承受托類。

作者：小村醫(yī) 原文：jianshu.com/p/3f04b6aebad2