作者：小村醫
來源：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 (base > 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、以繼承取代委託
你在兩個類中使用委託關係，並經常為整個接口編寫許多極簡單的委託函數。`讓委託類繼承受託類。