代码重构

时间 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这里没法给出，缘由是由于它的小实例会毫无心义，无非就是子类有同样的属性或者方法，而后删除子类的重复属性或方法放到父类当中。

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