揭秘代码中的常见坏味道及重构技巧（上）

2023-10-28 00:28:07

在软件开发领域，代码的质量至关重要。高质量的代码易于理解、维护和扩展，而低质量的代码则容易出现问题，导致项目延期、成本超支甚至更严重的后果。

代码中常见的坏味道是导致代码质量低下的主要原因之一。所谓坏味道，是指代码中存在的违反设计原则、降低代码可读性、可维护性的缺陷。

本文将对代码中的常见坏味道进行详细分析，并提供重构技巧，帮助您提高代码质量，编写出整洁、易于维护的代码。

1. 长变量名

长变量名是代码中常见的坏味道之一。变量名过长会降低代码的可读性，使代码难以理解和维护。例如，以下代码中的变量名longVariableName就非常不直观：

int longVariableName = 10;

更好的做法是使用短而有意义的变量名，例如：

int num = 10;

2. 重复代码

重复代码是代码中另一个常见的坏味道。重复代码不仅降低了代码的可维护性，而且容易导致错误。例如，以下代码中的两段代码重复实现了同样的功能：

public void calculate() {
    int sum = 0;
    for (int i = 0; i < 10; i++) {
        sum += i;
    }
    return sum;
}

public void calculate2() {
    int sum = 0;
    for (int i = 0; i < 10; i++) {
        sum += i;
    }
    return sum;
}

更好的做法是将重复的代码提取到一个单独的方法中，例如：

public int calculate() {
    int sum = 0;
    for (int i = 0; i < 10; i++) {
        sum += i;
    }
    return sum;
}

public void calculate2() {
    int sum = calculate();
    return sum;
}

3. 注释缺失

注释是代码中不可或缺的一部分。注释可以帮助其他开发人员理解代码的意图和用法，使代码更易于维护。例如，以下代码中的注释就非常有用：

// 计算数组中所有元素的和
int sum = 0;
for (int i = 0; i < array.length; i++) {
    sum += array[i];
}
return sum;

更好的做法是在代码中添加必要的注释，例如：

/**
 * 计算数组中所有元素的和
 * @param array 要计算和的数组
 * @return 数组中所有元素的和
 */
int sum(int[] array) {
    int sum = 0;
    for (int i = 0; i < array.length; i++) {
        sum += array[i];
    }
    return sum;
}

4. 复杂条件语句

复杂条件语句是代码中常见的坏味道之一。复杂条件语句很难理解和维护，容易导致错误。例如，以下代码中的条件语句非常复杂：

if (a > b && c < d || e != f && g == h) {
    // do something
}

更好的做法是将复杂条件语句分解成多个简单的条件语句，例如：

if (a > b) {
    if (c < d) {
        // do something
    }
}

if (e != f) {
    if (g == h) {
        // do something
    }
}

5. 过长的函数

过长的函数是代码中常见的坏味道之一。过长的函数很难理解和维护，容易导致错误。例如，以下代码中的函数doSomething()就非常长：

public void doSomething() {
    // do something
    // do something
    // do something
    // do something
    // do something
}

更好的做法是将过长的函数分解成多个较短的函数，例如：

public void doSomething() {
    doSomething1();
    doSomething2();
    doSomething3();
}

private void doSomething1() {
    // do something
}

private void doSomething2() {
    // do something
}

private void doSomething3() {
    // do something
}

6. 神奇数字

神奇数字是代码中常见的坏味道之一。神奇数字是指那些没有意义的数字常量，例如：

final int MAGIC_NUMBER = 12345;

更好的做法是使用有意义的常量名来代替神奇数字，例如：

final int MAX_SIZE = 100;

7. 全局变量

全局变量是代码中常见的坏味道之一。全局变量很容易导致命名冲突，使代码难以理解和维护。例如，以下代码中的全局变量g_value就很容易导致命名冲突：

int g_value = 10;

更好的做法是使用局部变量来代替全局变量，例如：

public void doSomething() {
    int value = 10;
    // do something
}

8. 硬编码

硬编码是代码中常见的坏味道之一。硬编码是指将配置信息直接写入代码中，例如：

final String URL = "http://example.com";

更好的做法是将配置信息从代码中分离出来，例如：

final String URL = readConfig("url");

9. 重复逻辑

重复逻辑是代码中常见的坏味道之一。重复逻辑不仅降低了代码的可维护性，而且容易导致错误。例如，以下代码中的两段代码重复实现了同样的功能：

public void doSomething1() {
    if (a > b) {
        // do something
    } else {
        // do something else
    }
}

public void doSomething2() {
    if (c > d) {
        // do something
    } else {
        // do something else
    }
}

更好的做法是将重复的逻辑提取到一个单独的方法中，例如：

public void doSomething(int a, int b) {
    if (a > b) {
        // do something
    } else {
        // do something else
    }
}

public void doSomething1() {
    doSomething(a, b);
}

public void doSomething2() {
    doSomething(c, d);
}

10. 过长的参数列表

过长的参数列表是代码中常见的坏味道之一。过长的参数列表很难理解和维护，容易导致错误。例如，以下代码中的函数doSomething()的参数列表非常长：

public void doSomething(int a, int b, int c, int d, int e, int f, int g, int h) {
    // do something
}

更好的做法是将参数列表分解成多个较短的参数列表，例如：

public void doSomething(int a, int b) {
    // do something
}

public void doSomething2(int c, int d) {
    // do something
}

public void doSomething3(int e, int f) {
    // do something
}

public void doSomething4(int g, int h) {
    // do something
}

11. 高度耦合

高度耦合是代码中常见的坏味道之一。高度耦合是指代码中的模块或类之间存在过多的依赖关系，导致代码难以理解和维护。例如，以下代码中的两个类A和B高度耦合：

public class A {
    private B b;

    public void doSomething() {
        b.doSomething();
    }
}

public class B {
    public void doSomething() {
        // do something
    }
}

更好的做法是降低代码中的耦合度，例如：

public class A {
    private B b;

    public void doSomething() {
        IB b = new B();
        b.doSomething();
    }
}

public interface IB {
    void doSomething();
}

public class B implements IB {
    public void doSomething() {
        // do something
    }
}