點擊下載
本文文檔

當前位置：首頁 - 科技 - 知識百科 - 正文

重構的10個小技巧

來源：懂視網責編：小采時間：2020-11-09 07:29:07

重構的10個小技巧

重構的10個小技巧:重構的手法有很多種，相對而言，一篇文章的涵蓋量自然是無法提到所有，LZ這里也只能提出一些平時會經常使用的一些手法，像一些比較高端的手法，各位有興趣的可以去找一些專門的書籍涉獵。另外還有一點，由于LZ是做JAVA開發的，因此部分重構小技巧可能與JA

推薦度：

點擊下載本文 文檔為doc格式

導讀重構的10個小技巧:重構的手法有很多種，相對而言，一篇文章的涵蓋量自然是無法提到所有，LZ這里也只能提出一些平時會經常使用的一些手法，像一些比較高端的手法，各位有興趣的可以去找一些專門的書籍涉獵。另外還有一點，由于LZ是做JAVA開發的，因此部分重構小技巧可能與JA

重構的手法有很多種，相對而言，一篇文章的涵蓋量自然是無法提到所有，LZ這里也只能提出一些平時會經常使用的一些手法，像一些比較高端的手法，各位有興趣的可以去找一些專門的書籍涉獵。另外還有一點，由于LZ是做JAVA開發的，因此部分重構小技巧可能與JAVA

重構的手法有很多種，相對而言，一篇文章的涵蓋量自然是無法提到所有，LZ這里也只能提出一些平時會經常使用的一些手法，像一些比較高端的手法，各位有興趣的可以去找一些專門的書籍涉獵。

另外還有一點，由于LZ是做JAVA開發的，因此部分重構小技巧可能與JAVA語言，或者說與面向對象的語言息息相關，不過大多數技巧，無論是面向過程的語言，還是面向對象的語言，都是可以相互通用的。

廢話不多說，我們來看看實用重構技巧的排行榜吧。

No.1：重復代碼的提煉

重復代碼是重構收效最大的手法之一，進行這項重構的原因不需要多說。它有很多很明顯的好處，比如總代碼量大大減少，維護方便，代碼條理更加清晰易讀。

它的重點就在于尋找代碼當中完成某項子功能的重復代碼，找到以后請毫不猶豫將它移動到合適的方法當中，并存放在合適的類當中。

小實例

class BadExample {

 public void someMethod1(){
 //code
 System.out.println("重復代碼");/* 重復代碼塊 */
 //code
 }
 
 public void someMethod2(){
 //code
 System.out.println("重復代碼");/* 重復代碼塊 */
 //code
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {

 public void someMethod1(){
 //code
 someMethod3();
 //code
 }
 
 public void someMethod2(){
 //code
 someMethod3();
 //code
 }
 
 public void someMethod3(){
 System.out.println("重復代碼");/* 重復代碼塊 */
 }
 
}

No.2：冗長方法的分割

有關冗長方法的分割，其實有時候與重復代碼的提煉是有著不可分割的關系的，往往在我們提煉重復代碼的過程中，就不知不覺的完成了對某一個超長方法的分割。倘若在你提煉了大部分的重復代碼之后，某一些冗長方法依然留存，此時就要靜下心來專門處理這些冗長方法了。

這其中有一點是值得注意的，由于我們在分割一個大方法時，大部分都是針對其中的一些子功能分割，因此我們需要給每一個子功能起一個恰到好處的方法名，這很重要。可以說，能否給方法起一個好名字，有時候能體現出一個程序猿的大致水準。

小實例

class BadExample {

 public void someMethod(){
 //function[1]
 //function[2]
 //function[3]
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {

 public void someMethod(){
 function1();
 function2();
 function3();
 }
 
 private void function1(){
 //function[1]
 }
 
 private void function2(){
 //function[2]
 }

 private void function3(){
 //function[3]
 }
 
}

No.3：嵌套條件分支的優化（1）

大量的嵌套條件分支是很容易讓人望而卻步的代碼，我們應該極力避免這種代碼的出現。盡管結構化原則一直在說一個函數只能有一個出口，但是在這么大量的嵌套條件分支下，讓我們忘了這所謂的規則吧。

有一個專業名詞叫衛語句，可以治療這種恐怖的嵌套條件語句。它的核心思想是，將不滿足某些條件的情況放在方法前面，并及時跳出方法，以免對后面的判斷造成影響。經過這項手術的代碼看起來會非常的清晰，下面LZ就給各位舉一個經典的例子，各位可以自行評判一下這兩種方式，哪個讓你看起來更清晰一點。

小實例

class BadExample {

 public void someMethod(Object A,Object B){
 if (A != null) {
 if (B != null) {
 //code[1]
 }else {
 //code[3]
 }
 }else {
 //code[2]
 }
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {

 public void someMethod(Object A,Object B){
 if (A == null) {
 //code[2]
 return;
 }
 if (B == null) {
 //code[3]
 return;
 }
 //code[1]
 }
 
}

No.4：嵌套條件分支的優化（2）

此處所說的嵌套條件分支與上面的有些許不同，它無法使用衛語句進行優化，而應該是將條件分支合并，以此來達到代碼清晰的目的。由這兩條也可以看出，嵌套條件分支在編碼當中應當盡量避免，它會大大降低代碼的可讀性。

下面請尚且不明覺厲的猿友看下面這個典型的小例子。

小實例

class BadExample {

 public void someMethod(Object A,Object B){
 if (A != null) {
 if (B != null) {
 //code
 }
 }
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {

 public void someMethod(Object A,Object B){
 if (A != null && B != null) {
 //code
 }
 }
 
}

No.5：去掉一次性的臨時變量

生活當中我們都經常用一次性筷子，這無疑是對樹木的摧殘。然而在程序當中，一次性的臨時變量不僅是對性能上小小的摧殘，更是對代碼可讀性的褻瀆。因此我們有必要對一些一次性的臨時變量進行手術。

小實例

class BadExample {
 
 private int i;

 public int someMethod(){
 int temp = getVariable();
 return temp * 100;
 }
 
 public int getVariable(){
 return i;
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {

 private int i;

 public int someMethod(){
 return getVariable() * 100;
 }
 
 public int getVariable(){
 return i;
 }
 
}

No.6：消除過長參數列表

對于一些傳遞了大批參數的方法，對于追求代碼整潔的程序猿來說，是無法接受的。我們可以嘗試將這些參數封裝成一個對象傳遞給方法，從而去除過長的參數列表。大部分情況下，當你嘗試尋找這樣一個對象的時候，它往往已經存在了，因此絕大多數情況下，我們并不需要做多余的工作。

小實例

class BadExample {
 
 public void someMethod(int i,int j,int k,int l,int m,int n){
 //code
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {

 public void someMethod(Data data){
 //code
 }
 
}

class Data{
 
 private int i;
 private int j;
 private int k;
 private int l;
 private int m;
 private int n;　　//getter&&setter
 
}

No.7：提取類或繼承體系中的常量

這項重構的目的是為了消除一些魔數或者是字符串常量等等，魔數所帶來的弊端自不用說，它會讓人對程序的意圖產生迷惑。而對于字符串等類型的常量的消除，更多的好處在于維護時的方便。因為我們只需要修改一個常量，就可以完成對程序中所有使用該常量的代碼的修改。

順便提一句，與此類情況類似并且最常見的，就是Action基類中，對于INPUT、LIST、SUCCESS等這些常量的提取。

小實例

class BadExample {
 
 public void someMethod1(){
 send("您的操作已成功！");
 }
 
 public void someMethod2(){
 send("您的操作已成功！");
 }
 
 public void someMethod3(){
 send("您的操作已成功！");
 }
 
 private void send(String message){
 //code
 }
}

/* ---------------------分割線---------------------- */

class GoodExample {
 
 protected static final String SUCCESS_MESSAGE = "您的操作已成功！";

 public void someMethod1(){
 send(SUCCESS_MESSAGE);
 }
 
 public void someMethod2(){
 send(SUCCESS_MESSAGE);
 }
 
 public void someMethod3(){
 send(SUCCESS_MESSAGE);
 }
 
 private void send(String message){
 //code
 }
 
}

No.8：讓類提供應該提供的方法

很多時候，我們經常會操作一個類的大部分屬性，從而得到一個最終我們想要的結果。這種時候，我們應該讓這個類做它該做的事情，而不應該讓我們替它做。而且大部分時候，這個過程最終會成為重復代碼的根源。

小實例

class BadExample {
 
 public int someMethod(Data data){
 int i = data.getI();
 int j = data.getJ();
 int k = data.getK();
 return i * j * k;
 }
 
 public static class Data{
 
 private int i;
 private int j;
 private int k;
 
 public Data(int i, int j, int k) {
 super();
 this.i = i;
 this.j = j;
 this.k = k;
 }

 public int getI() {
 return i;
 }
 
 public int getJ() {
 return j;
 }
 
 public int getK() {
 return k;
 }
 
 }
 
}

/* ---------------------分割線---------------------- */

class GoodExample {
 
 public int someMethod(Data data){
 return data.getResult();
 }
 
 public static class Data{
 
 private int i;
 private int j;
 private int k;
 
 public Data(int i, int j, int k) {
 super();
 this.i = i;
 this.j = j;
 this.k = k;
 }

 public int getI() {
 return i;
 }
 
 public int getJ() {
 return j;
 }
 
 public int getK() {
 return k;
 }
 
 public int getResult(){
 return i * j * k;
 }
 
 }
 
}

No.9：拆分冗長的類

這項技巧其實也是屬于非常實用的一個技巧，只不過由于它的難度相對較高，因此被LZ排在了后面。針對這個技巧，LZ很難像上面的技巧一樣，給出一個即簡單又很容易說明問題的小例子，因為它已經不僅僅是小手段了。

大部分時候，我們拆分一個類的關注點應該主要集中在類的屬性上面。拆分出來的兩批屬性應該在邏輯上是可以分離的，并且在代碼當中，這兩批屬性的使用也都分別集中于某一些方法當中。如果實在有一些屬性同時存在于拆分后的兩批方法內部，那么可以通過參數傳遞的方式解決這種依賴。

類的拆分是一個相對較大的工程，畢竟一個大類往往在程序中已經被很多類所使用著，因此這項重構的難度相當之大，一定要謹慎，并做好足夠的測試。

No.10：提取繼承體系中重復的屬性與方法到父類

這項技巧大部分時候需要足夠的判斷力，很多時候，這其實是在向模板方法模式邁進的過程。它的實例LZ這里無法給出，原因是因為它的小實例會毫無意義，無非就是子類有一樣的屬性或者方法，然后刪除子類的重復屬性或方法放到父類當中。

往往這一類重構都不會是小工程，因此這一項重構與第九種類似，都需要足夠的謹慎與測試。而且需要在你足夠確認，這些提取到父類中的屬性或方法，應該是子類的共性的時候，才可以使用這項技巧。

結束語

由于LZ目前的工作就是維護一個相對古老的項目，因此上面這十種手法，LZ幾乎都已經一一嘗試過了，可喜的是效果都還不錯。

限于最后兩種與實際情況的聯系太過緊密，因此LZ無法給出簡單的實例，不過后面兩種畢竟不是常用的重構手法，因此也算是可以接受了。不過不常用不代表不重要，各位猿友還是要知道這一點的。另外LZ還要說的是，上面的實例只是手法的一種簡單展示，實際應用當中，代碼的結構可能是千奇百怪，但卻萬變不離其宗。因此只要抓住每種手法的核心，就不難從這些亂軍叢中安然穿過。

好了，本次的小分享到此結束，希望各位猿友如果覺得有所收獲，可以推薦一下鼓勵下LZ，順便也讓更多的人看到。這樣的話，或許我們每一個接手的項目代碼，都不至于十分的糟糕了，也算是給像LZ這樣的項目維護者一條生路吧。

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com

重構的10個小技巧

推薦度：

點擊下載本文 文檔為doc格式

標簽：幾個小技巧技巧

熱門焦點

重構的10個小技巧

重構的10個小技巧

重構的10個小技巧

最新推薦

猜你喜歡

熱門推薦