作者：小村醫

https://www.jianshu.com/p/3f04b6aebad2

狗屎一樣的代碼如何重構？

重構不止是代碼整理，它提供了一種高效且受控的代碼整理技術。

（一）重構原則

---

1、何謂重構

對軟件內部結構的一種調整，目的是在不改變軟件可觀察行為的前提下，提高其可理解性，降低其修改成本。

另一種解釋是：使用一系列重構手法，在不改變軟件可觀察行為的前提下，調整其結構。

2、為何重構

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

3、何時重構

任何情況下我都反對專門撥出時間進行重構。重構本來就不是一件應該特別撥出時間做的事情，重構應該隨時隨地的進行。

三次法則

第一次做某件事情是只管去做；第二次做類似的事情會產生反感；第三次再做類似的事，你就應該重構。

最常見的重構時機是想給軟件添加新特性的時候；

重構的另一個原動力是：代碼的設計無法幫助我輕松的添加所需要的特性。

修改錯誤的時候，review代碼的時候重構。

間接層和重構

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

大多數重構都為程序引入了更多的間接層，重構往往把大型的對象拆成多個小型的對象，把大型的函數拆成多個小型的函數。但是，間接層是一把雙刃劍。每次把一個東西分成兩份，你就需要多管理一個東西。如果某個對象委托另一個對象，后者又委托另一個對象，程序會愈加難以閱讀。

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

重寫而非重構的一個清楚訊號是：現有代碼根本不能正常運作。

?

（二）代碼的壞味道

---

1、重復代碼

如果你在一個以上的地點看到相同的程序結構，那么可以肯定：設法將它們合二為一，程序會變得更好 。

同一個類中有相同的表達式：提煉出重復的代碼，然后讓兩個地方都調用被提煉出來的那一段代碼；

兩個互為兄弟的子類內含有相同的表達式：提煉出相同代碼，將它推入超類內；

兩個毫不相干的類中出現：將重復的代碼提煉到一個獨立的類中。

2、過長的類

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

每當感覺需要以注釋來說明點什么的時候，我們就把需要說明的東西寫進一個獨立的函數中。

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

條件表達式和循環常常也是提煉的信號。

3、過大的類

如果想利用單個類做太多的事情，其內往往就會出現太多實例變量。
類內如果有太多代碼，也是代碼重復、混亂病最終走向死亡的源頭。

4、過長參數列

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

5、發散式變化

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

6、散彈式修改

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

把所有需要修改的代碼放進同一個類中，如果眼下沒有合適的類可以安置這些代碼那就創造一個。

7、依戀情結

對象技術的要點在于：將數據和對數據的操作行為包裝在一起。有一種經典的氣味是：函數對某個類的興趣高過對自己所處類的興趣。某個函數為了計算某個值，從另一個對象那調用幾乎半打的取值函數。

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

8、數據泥團

很多地方看到相同的三四項數據一起出現。這些總是綁在一起出現的數據應該擁有屬于他們自己的對象。

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

9、基本類型偏執

對象的一個極大價值在于：它們模糊了基本數據和體積較大的類之間的界限

對象技術的新手通常不愿意在小任務上運用小對象——結合數值和比重的Money類、有一個起始值和一個結束值組成的Range類。將原本單獨存在的數值替換成對象，從而走出傳統的洞窟，進入炙手可熱的對象世界。

10、switch驚悚現身

面向對象的一個最明顯的特征是：少用switch語句------看到switch語句，就應該考慮以多態來替換它。

如果只是在單一函數中有些選擇實例，且并不想改動它們，那么多態就有點殺雞用牛刀了。

11、平行集成體系

每當你為某個類增加一個子類，必須也為另一個類相應增加一個子類。
消除這種重復性的一般策略是：讓一個繼承體系的實例引用另一個繼承體系的實例。

12、冗余類

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

13、夸夸其談未來性

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

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

14、令人迷惑的暫時字段

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

15、過度耦合消息鏈

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

16、中間人

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

17、狎昵關系

有時會看到兩個類過于親密，花費太多的時間去探究彼此的private成分。過分狎昵的類必須拆散，幫它們劃清界線，從而減少狎昵行徑。
繼承往往造成過度親密，因為子類對超類的了解總是超過后者的主觀愿望。如果你覺得該讓孩子獨立生活了，讓他離開繼承。

18、異曲同工的類

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

19、不完美的類庫

類庫函數構造的不夠好，又不能修改它們：

如果只想修改類的一兩個函數，可以引入外加函數。如果想要添加一大堆額外行為，建立一個新類包含這些額外行為，讓其成為子類。

20、純稚的數據類

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

• 封裝public字段;

• 恰當封裝容器類字段;

• 移除不應修改的字段的設置函數;

• 提煉調用函數以隱藏取值/設值函數;

21、被拒絕的遺贈

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

22、過多的注釋

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

當你感覺需要撰寫注釋時，請先嘗試重構，試著讓所有的注釋都變得多余。

?

（三）重新組織函數

---

1、提煉函數

動機：

看到一個過長的函數或者一段需要注釋才能讓人理解用途的代碼，將這段代碼放入一個獨立的函數中；
做法：

創造一個新函數，根據這個函數的意圖來命名它；

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

將提煉的代碼從原函數復制到新建的目標函數中；
將被提煉代碼段中需要讀取的局部變量，當作參數傳遞給目標函數；
在源函數中，將被提煉代碼段替換為目標函數調用。

2、內聯函數

一個函數的本體與名稱同樣清楚易懂。在函數調用點插入函數本體，然后移除該函數。
動機：

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

做法：

1、檢查函數，確定不具備多態；

如果子類繼承了這個函數，就不要將此函數內聯，因為子類無法復寫一個根本不存在的函數。

2、找出這個函數的所有調用點；

3、將這個函數的所有調用點都替換成函數本體。

3、內聯臨時變量

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

double basePrice = anOrder.basePrice(); return (basePrice > 10000 ); 替換為： return (anOrder.basePrice > 1000);

4、以查詢取代臨時變量

你的程序以一個臨時變量保存某一表達式的運算結果。將這個表達式提煉到一個獨立的函數中。將這個臨時變量的所有引用點替換為對新函數的調用。此后，新函數就可被其他函數使用。

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

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

5、引入注釋性變量

你有一個復雜的表達式。將該復雜表達式（或其中一部分）的結果放進一個臨時變量，以此變量名稱來解釋表達式用途。

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 }

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

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

6、分解臨時變量

你的程序有某個臨時變量被賦值超過一次，它既不是循環變量，也不被用于收集計算結果。 針對每次賦值，創造一個獨立、對應的臨時變量。

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

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

7、移除對參數的賦值

代碼對一個參數進行賦值。以一個臨時變量取代該參數的位置。

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

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

8、替換算法

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

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

?

（四）在對象之間搬移特性

---

在對象設計過程中，決定把責任放在哪兒即使不是最重要的事，也是最重要的事之一。

常常只使用搬移函數和搬移字段簡單地移動對象行為，就可以解決這些問題。如果這兩個重構手法都需要用到，我會首先使用搬移字段，再使用搬移方法。

如果一個類承擔了太多責任而變得臃腫不堪，這種情況下會使用提煉類將一部分責任分離出去。如果一個類變得太不負責任，使用將類內聯化將它融入到另一個類中。

1、搬移函數

你的程序中，有個函數與其所駐類之外的另一個類進行過的交流：調用后者或被后者調用。在該函數最長引用的類中建立一個有著類似行為的新函數。將舊函數變成一個單純的委托函數，或者將舊函數完全移除。
如果一個類有太多行為，或如果一個類與另一個類有太多合作而高度耦合，就需要搬移函數。可以使系統中的類更簡單。

2、搬移字段

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

3、提煉類

某個類做了應該由兩個類做的事。建立一個新類，將相關字段和函數從舊類搬到新類。

4、將類內聯化

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

5、隱藏“委托關系”

客戶通過一個委托類來調用另一個對象。在服務類上建立客戶所需要的所有函數，用來隱藏委托關系。

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

如果某個客戶先通過服務對象的字段得到另一個對象，然后調用后者的函數。那么客戶就必須知曉這一層委托關系。萬一委托關系變化，客戶也要相應變化。

6、移除中間人

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

7、引入外加函數

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

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

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

8、引入本地擴展

你需要為服務類提供一些額外函數，但你無法修改這個類。建立一個新類，使它包含這些額外函數。讓這個擴展品成為源類的子類或包裝類。

?

（五）重新組織數據

---

1、自封裝字段

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

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

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

• 在該變量定義所在的類中，你可以自由的訪問。

• 即使在這個類中你也應該只使用訪問函數間接訪問。
  *間接訪問的好處是：子類可以通過復寫一個函數而改變獲取數據的途徑；它支持更靈活的數據管理方式，例如延遲初始化。

2、以對象取代數據值

你有一個數據項，需要與其他數據和行為一起使用才有意義。將數據項變為對象。

一開始你肯能會用一個字符串來表示“電話號碼”概念，但是隨后你會發現，電話號碼需要“格式化”、“區號”之類的行為。這時候就需要為待替換的數值新建一個類。

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

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

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

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

5、以對象取代數組

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

6、復制“被監視數據”

你有一些領域數據置身GUI控件中，而領域函數需要訪問這些數據。將該數據復制到一個領域對象中。建立一個Observer模式，用以同步領域對象和GUI對象內的重復數據。

7、將單向關聯改為雙向關聯

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

8、將雙向關聯改為單向關聯

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

9、以字面常量取代魔數

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

10、封裝字段

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

11、封裝集合

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

?

（六）簡化條件表達式

---

1、分解條件表達式

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

2、合并表達式

你有一系列條件測試，都得到相同結果。將這些測試合并為一個條件表達式，并將這個條件表達式提煉成一個獨立函數。

3、合并重復的條件代碼

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

4、移除控制標記

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

5、以多態取代條件表達式

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

?

（七）簡化函數調用

---

1、函數改名

函數的名稱未能揭示其用途。 修改函數名稱。

2、添加參數

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

3、移除參數

函數本體不再需要某個參數。 去除參數。

4、分離查詢函數和修改函數

某個函數既返回對象狀態值，又修改對象值。 建立兩個不同函數，其中一個負責查詢，另一個負責修改。

5、令函數攜帶參數

若干函數做了類似的工作，但在函數本體中包含了不同的值。建立單一函數，以參數表達那些不同的值。
有這樣兩個函數：它們做著類似的工作，但因少數幾個值致使行為略有不同。在這種情況下，你可以將這些各自分離的函數同一起來，并通過參數來處理那些變化情況，用以簡化問題。

6、以明確函數取代參數

你有一個函數，其中完全取決于參數值而采用不同行為。 針對該參數的每一個可能值，建立一個獨立函數。
如果某個參數有多種可能的值，而函數內又以條件表達式檢查這些參數值，并根據不同參數值做出不同的行為，那么就應該使用本項重構。

7、保持對象完整

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

8、以函數取代參數

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

9、引入參數對象

某些參數總是很自然的同時出現。以一個對象取代這些參數。

10、移除設值函數

類中某個字段在對象創建時被設值，然后不再改變。去掉該字段的所有設值函數。

11、隱藏函數

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

12 、以工廠函數取代構造函數

希望在創建對象時不僅僅是做簡單的建構動作 。 將構造函數替換為工廠函數。

?

（八）處理概括關系

---

1、字段上移

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

2 、函數上移

有些函數在各子類中產生完全相同的結果。將該函數移至超類。

3 、構造函數本體上移

各個子類中有一些構造函數本體幾乎完全一致 。在超類中新建一個構造函數，并在子類構造函數中調用它。

4、函數下移

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

5、字段下移

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

6、提煉子類

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

7、提煉超類

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

8、提煉接口

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

9、折疊繼承體系

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

10、塑造模板函數

子類中某些函數以相同順序執行類似操作，但各操作細節略有不同。將操作放進獨立函數(保持簽名相同)，然后將它們移至超類。

11、以委托取代繼承

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

12、以繼承取代委托

你在兩個類中使用委托關系，并經常為整個接口編寫許多極簡單的委托函數。`讓委托類繼承受托類。

總結

以上是生活随笔為你收集整理的关于重构，看此文就够了的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。