代碼重構

時間  2019-11-19
標籤 代碼 简体版
原文   原文鏈接

本次咱們拋開JAVA虛擬機源碼這些相對底層的東西，LZ來與各位探討一下幾個代碼重構的小技巧，這些內容部分來自於書籍當中，部分來自於LZ維護項目當中的一些實踐經驗。若是猿友們曾經用過這種手法，也不妨參與到文章的留言當中，將你的當心得、小體會共享與他人，也能夠拿來衝擊LZ本身定義的排行榜，LZ不甚歡迎。函數

           重構的手法有不少種，相對而言，一篇文章的涵蓋量天然是沒法提到全部，LZ這裏也只能提出一些平時會常用的一些手法，像一些比較高端的手法，各位有興趣的能夠去找一些專門的書籍涉獵。性能

           另外還有一點，因爲LZ是作JAVA開發的，所以部分重構小技巧可能與JAVA語言，或者說與面向對象的語言息息相關，不過大多數技巧，不管是面向過程的語言，仍是面向對象的語言，都是能夠相互通用的。測試

           廢話很少說，咱們來看看實用重構技巧的排行榜吧。優化

 

No.1：重複代碼的提煉

 

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

           它的重點就在於尋找代碼當中完成某項子功能的重複代碼，找到之後請堅決果斷將它移動到合適的方法當中，並存放在合適的類當中。編碼

 

小實例

           

複製代碼

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：冗長方法的分割

 

         有關冗長方法的分割，其實有時候與重複代碼的提煉是有着不可分割的關係的，每每在咱們提煉重複代碼的過程當中，就不知不覺的完成了對某一個超長方法的分割。假若在你提煉了大部分的重複代碼以後，某一些冗長方法依然留存，此時就要靜下心來專門處理這些冗長方法了。spa

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

 

小實例

 

複製代碼

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這裏沒法給出，緣由是由於它的小實例會毫無心義，無非就是子類有同樣的屬性或者方法，而後刪除子類的重複屬性或方法放到父類當中。

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

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程