suchen

Heim >Datenbank >MySQL-Tutorial >重构的10个小技巧

重构的10个小技巧

WBOY
WBOYOriginal
2016-06-07 15:36:141143Durchsuche

重构的手法有很多种，相对而言，一篇文章的涵盖量自然是无法提到所有，LZ这里也只能提出一些平时会经常使用的一些手法，像一些比较高端的手法，各位有兴趣的可以去找一些专门的书籍涉猎。 另外还有一点，由于LZ是做JAVA开发的，因此部分重构小技巧可能与JAVA

 重构的手法有很多种，相对而言，一篇文章的涵盖量自然是无法提到所有，LZ这里也只能提出一些平时会经常使用的一些手法，像一些比较高端的手法，各位有兴趣的可以去找一些专门的书籍涉猎。

           另外还有一点，由于LZ是做JAVA开发的，因此部分重构小技巧可能与JAVA语言，或者说与面向对象的语言息息相关，不过大多数技巧，无论是面向过程的语言，还是面向对象的语言，都是可以相互通用的。

           废话不多说，我们来看看实用重构技巧的排行榜吧。

 

No.1：重复代码的提炼

 

           重复代码是重构收效最大的手法之一，进行这项重构的原因不需要多说。它有很多很明显的好处，比如总代码量大大减少，维护方便，代码条理更加清晰易读。

           它的重点就在于寻找代码当中完成某项子功能的重复代码，找到以后请毫不犹豫将它移动到合适的方法当中，并存放在合适的类当中。

 

小实例

           

重构的10个小技巧

<span><span>class</span><span> BadExample {

    </span><span>public</span> <span>void</span><span> someMethod1(){
        </span><span>//</span><span>code</span>
        System.out.println("重复代码");<span>/*</span><span> 重复代码块 </span><span>*/</span>
        <span>//</span><span>code</span>
<span>    }
    
    </span><span>public</span> <span>void</span><span> someMethod2(){
        </span><span>//</span><span>code</span>
        System.out.println("重复代码");<span>/*</span><span> 重复代码块 </span><span>*/</span>
        <span>//</span><span>code</span>
<span>    }
    
}

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

<span>class</span><span> GoodExample {

    </span><span>public</span> <span>void</span><span> someMethod1(){
        </span><span>//</span><span>code</span>
<span>        someMethod3();
        </span><span>//</span><span>code</span>
<span>    }
    
    </span><span>public</span> <span>void</span><span> someMethod2(){
        </span><span>//</span><span>code</span>
<span>        someMethod3();
        </span><span>//</span><span>code</span>
<span>    }
    
    </span><span>public</span> <span>void</span><span> someMethod3(){
        System.out.println(</span>"重复代码");<span>/*</span><span> 重复代码块 </span><span>*/</span><span>
    }
    
}</span></span>

重构的10个小技巧

 

No.2：冗长方法的分割

 

         有关冗长方法的分割，其实有时候与重复代码的提炼是有着不可分割的关系的，往往在我们提炼重复代码的过程中，就不知不觉的完成了对某一个超长方法的分割。倘若在你提炼了大部分的重复代码之后，某一些冗长方法依然留存，此时就要静下心来专门处理这些冗长方法了。

         这其中有一点是值得注意的，由于我们在分割一个大方法时，大部分都是针对其中的一些子功能分割，因此我们需要给每一个子功能起一个恰到好处的方法名，这很重要。可以说，能否给方法起一个好名字，有时候能体现出一个程序猿的大致水准。

 

小实例

 

重构的10个小技巧

<span><span>class</span><span> BadExample {

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

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

<span>class</span><span> GoodExample {

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

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

重构的10个小技巧

 

No.3：嵌套条件分支的优化（1）

 

           大量的嵌套条件分支是很容易让人望而却步的代码，我们应该极力避免这种代码的出现。尽管结构化原则一直在说一个函数只能有一个出口，但是在这么大量的嵌套条件分支下，让我们忘了这所谓的规则吧。

           有一个专业名词叫卫语句，可以治疗这种恐怖的嵌套条件语句。它的核心思想是，将不满足某些条件的情况放在方法前面，并及时跳出方法，以免对后面的判断造成影响。经过这项手术的代码看起来会非常的清晰，下面LZ就给各位举一个经典的例子，各位可以自行评判一下这两种方式，哪个让你看起来更清晰一点。

 

小实例

           

重构的10个小技巧

<span><span>class</span><span> BadExample {

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

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

<span>class</span><span> GoodExample {

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

重构的10个小技巧

 

No.4：嵌套条件分支的优化（2）

           

          此处所说的嵌套条件分支与上面的有些许不同，它无法使用卫语句进行优化，而应该是将条件分支合并，以此来达到代码清晰的目的。由这两条也可以看出，嵌套条件分支在编码当中应当尽量避免，它会大大降低代码的可读性。

          下面请尚且不明觉厉的猿友看下面这个典型的小例子。

 

小实例

 

重构的10个小技巧

<span><span>class</span><span> BadExample {

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

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

<span>class</span><span> GoodExample {

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

重构的10个小技巧

 

No.5：去掉一次性的临时变量

 

         生活当中我们都经常用一次性筷子，这无疑是对树木的摧残。然而在程序当中，一次性的临时变量不仅是对性能上小小的摧残，更是对代码可读性的亵渎。因此我们有必要对一些一次性的临时变量进行手术。

 

小实例

 

重构的10个小技巧

<span><span>class</span><span> BadExample {
    
    </span><span>private</span> <span>int</span><span> i;

    </span><span>public</span> <span>int</span><span> someMethod(){
        </span><span>int</span> temp =<span> getVariable();
        </span><span>return</span> temp * 100<span>;
    }
    
    </span><span>public</span> <span>int</span><span> getVariable(){
        </span><span>return</span><span> i;
    }
    
}

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

<span>class</span><span> GoodExample {

    </span><span>private</span> <span>int</span><span> i;

    </span><span>public</span> <span>int</span><span> someMethod(){
        </span><span>return</span> getVariable() * 100<span>;
    }
    
    </span><span>public</span> <span>int</span><span> getVariable(){
        </span><span>return</span><span> i;
    }
    
}</span></span>

重构的10个小技巧

 

No.6：消除过长参数列表

 

          对于一些传递了大批参数的方法，对于追求代码整洁的程序猿来说，是无法接受的。我们可以尝试将这些参数封装成一个对象传递给方法，从而去除过长的参数列表。大部分情况下，当你尝试寻找这样一个对象的时候，它往往已经存在了，因此绝大多数情况下，我们并不需要做多余的工作。

 

小实例

 

重构的10个小技巧

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

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

<span>class</span><span> GoodExample {

    </span><span>public</span> <span>void</span><span> someMethod(Data data){
        </span><span>//</span><span>code</span>
<span>    }
    
}

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

重构的10个小技巧

 

No.7：提取类或继承体系中的常量

 

         这项重构的目的是为了消除一些魔数或者是字符串常量等等，魔数所带来的弊端自不用说，它会让人对程序的意图产生迷惑。而对于字符串等类型的常量的消除，更多的好处在于维护时的方便。因为我们只需要修改一个常量，就可以完成对程序中所有使用该常量的代码的修改。

         顺便提一句，与此类情况类似并且最常见的，就是Action基类中，对于INPUT、LIST、SUCCESS等这些常量的提取。

 

小实例

 

重构的10个小技巧

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

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

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

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

重构的10个小技巧

 

No.8：让类提供应该提供的方法

 

         很多时候，我们经常会操作一个类的大部分属性，从而得到一个最终我们想要的结果。这种时候，我们应该让这个类做它该做的事情，而不应该让我们替它做。而且大部分时候，这个过程最终会成为重复代码的根源。

 

小实例

 

重构的10个小技巧

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

        </span><span>public</span> <span>int</span><span> getI() {
            </span><span>return</span><span> i;
        }
        
        </span><span>public</span> <span>int</span><span> getJ() {
            </span><span>return</span><span> j;
        }
        
        </span><span>public</span> <span>int</span><span> getK() {
            </span><span>return</span><span> k;
        }
        
    }
    
}

</span><span>/*</span><span> ---------------------分割线---------------------- </span><span>*/</span>

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

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

重构的10个小技巧

 

No.9：拆分冗长的类

 

         这项技巧其实也是属于非常实用的一个技巧，只不过由于它的难度相对较高，因此被LZ排在了后面。针对这个技巧，LZ很难像上面的技巧一样，给出一个即简单又很容易说明问题的小例子，因为它已经不仅仅是小手段了。

         大部分时候，我们拆分一个类的关注点应该主要集中在类的属性上面。拆分出来的两批属性应该在逻辑上是可以分离的，并且在代码当中，这两批属性的使用也都分别集中于某一些方法当中。如果实在有一些属性同时存在于拆分后的两批方法内部，那么可以通过参数传递的方式解决这种依赖。

         类的拆分是一个相对较大的工程，毕竟一个大类往往在程序中已经被很多类所使用着，因此这项重构的难度相当之大，一定要谨慎，并做好足够的测试。

 

No.10：提取继承体系中重复的属性与方法到父类

 

         这项技巧大部分时候需要足够的判断力，很多时候，这其实是在向模板方法模式迈进的过程。它的实例LZ这里无法给出，原因是因为它的小实例会毫无意义，无非就是子类有一样的属性或者方法，然后删除子类的重复属性或方法放到父类当中。

         往往这一类重构都不会是小工程，因此这一项重构与第九种类似，都需要足够的谨慎与测试。而且需要在你足够确认，这些提取到父类中的属性或方法，应该是子类的共性的时候，才可以使用这项技巧。

 

结束语

 

         由于LZ目前的工作就是维护一个相对古老的项目，因此上面这十种手法，LZ几乎都已经一一尝试过了，可喜的是效果都还不错。

         限于最后两种与实际情况的联系太过紧密，因此LZ无法给出简单的实例，不过后面两种毕竟不是常用的重构手法，因此也算是可以接受了。不过不常用不代表不重要，各位猿友还是要知道这一点的。另外LZ还要说的是，上面的实例只是手法的一种简单展示，实际应用当中，代码的结构可能是千奇百怪，但却万变不离其宗。因此只要抓住每种手法的核心，就不难从这些乱军丛中安然穿过。

         好了，本次的小分享到此结束，希望各位猿友如果觉得有所收获，可以推荐一下鼓励下LZ，顺便也让更多的人看到。这样的话，或许我们每一个接手的项目代码，都不至于十分的糟糕了，也算是给像LZ这样的项目维护者一条生路吧。

         

         

Stellungnahme：
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel：数据库行列互换Nächster Artikel：数据库性能调优技术

In Verbindung stehende Artikel

Mehr sehen