静态方法转对象，提升代码可测试性

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《静态方法与变量重构为面向对象设计，核心在于将原本属于类的静态成员转换为实例成员，并通过实例化对象来调用。以下是具体步骤和示例：一、理解静态方法与变量的问题静态方法： 属于类本身，而非类的实例。 无法访问实例变量或方法（除非显式传递）。 通常用于工具函数、全局配置等。静态变量： 属于类级别的变量，所有实例共享。 适合存储全局状态，但容易引发多线程问题或难以测试。这些设计在某些场景下非常有用，但在需要灵活性、可扩展性、可测试性和依赖注入的场景中，会显得不够灵活。二、重构目标将静态方法和变量转换为面向对象的实例化设计，目的是：提高代码的可测试性（便于 Mock 和单元测试）。增强代码的可维护性和扩展性。避免全局状态带来的副作用。三、重构步骤1. 识别静态方法和变量的用途首先明确哪些静态方法和变量是“功能性的”，哪些是“状态性的”。功能性静态方法：如 Math.sqrt()、StringUtils.isEmpty() 等，通常是无状态的工具方法。**状态性静态变量》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

本文讲解如何将 Java 中过度依赖 static 的矩阵填充程序改造为符合面向对象原则的实例化结构，通过移除 static 修饰符、引入构造与实例方法，提升代码可维护性与可测试性。

在原始代码中，所有字段（如 matrix、rows、cols、enemy、target）和方法（如 matrixCreator、recursive、valid、printer）均被声明为 static，导致整个逻辑强耦合于类本身，丧失了面向对象的核心优势：封装、实例独立性与可重用性。例如，若需同时处理多个不同矩阵（如多组测试用例），静态设计将因共享状态而相互干扰。

要正确重构，核心原则是：将数据与行为绑定到对象实例上。具体步骤如下：

1. 移除所有 static 修饰符（字段与方法）；
2. 在 main 中创建类的实例，而非直接调用静态成员；
3. 将原 main 中的业务逻辑提取为一个非静态的入口方法（如 run() 或 start()），由实例调用；
4. 确保所有字段在实例方法中通过 this 隐式访问（无需显式前缀）。

以下是重构后的完整示例（关键改动已加注释）：

public class MatrixRefill {
    // ✅ 移除 static：变为实例字段
    private String[][] matrix;
    private int rows;
    private int cols;
    private String enemy;
    private String target;

    public static void main(String[] args) {
        // ✅ 在 main 中创建实例，并委托执行
        MatrixRefill app = new MatrixRefill();
        app.run(args); // 调用实例方法
    }

    // ✅ 非静态入口方法，接收参数并驱动流程
    public void run(String[] args) {
        if (args.length < 3) {
            throw new IllegalArgumentException("Usage: <matrix-string> <row,col> <target>");
        }
        target = args[2];
        // 解析位置：如 "2,1" → row=2, col=1
        String[] pos = args[1].split(",");
        rows = Integer.parseInt(pos[0].trim());
        cols = Integer.parseInt(pos[1].trim());

        matrix = matrixCreator(args[0]);
        enemy = matrix[rows][cols];
        recursive(rows, cols, target);
        printer(matrix);
    }

    // ✅ 所有辅助方法均改为实例方法（无 static）
    public String[][] matrixCreator(String mx) {
        int ro = 0, co = 0;
        for (int i = 0; i < mx.length(); i++) {
            if (mx.charAt(i) == ',') co++;
            else if (mx.charAt(i) == '-') ro++;
        }
        String[][] matriks = new String[ro + 1][co / 3 + 1]; // 注意：此解析逻辑需与输入格式严格匹配

        ro = 0; co = 0;
        for (int j = 0; j < mx.length(); j++) {
            char c = mx.charAt(j);
            if (c == ',') co++;
            else if (c == '-') {
                ro++; co = 0;
            } else if (Character.isLetter(c)) {
                matriks[ro][co] = String.valueOf(c);
            }
        }
        return matriks;
    }

    public void recursive(int row, int col, String target) {
        if (valid(row, col)) {
            matrix[row][col] = target;
            recursive(row + 1, col, target);
            recursive(row - 1, col, target);
            recursive(row, col + 1, target);
            recursive(row, col - 1, target);
        }
    }

    public boolean valid(int row, int col) {
        return row >= 0 && row < matrix.length
            && col >= 0 && col < matrix[row].length
            && enemy.equals(matrix[row][col]); // ✅ 使用 equals() 安全比较字符串
    }

    public void printer(String[][] owo) {
        for (int i = 0; i < owo.length; i++) {
            for (int j = 0; j < owo[i].length; j++) {
                System.out.print(owo[i][j]);
                if (j < owo[i].length - 1) System.out.print(" ");
            }
            System.out.println();
        }
    }
}

⚠️ 注意事项与优化建议：

• 空指针防护：valid() 中应先检查 matrix != null 和 matrix[row] != null，避免运行时异常；
• 递归深度风险：当前 recursive() 未标记已访问位置，可能导致无限递归或栈溢出——实际应引入 boolean[][] visited 或就地标记（如设为 null 或特殊占位符）；
• 输入解析健壮性：args[1] 解析使用 split(",") 比 substring() 更安全；矩阵字符串解析逻辑（如 co/3）需与真实输入格式对齐，建议补充单元测试验证；
• 职责分离：可进一步将矩阵解析、填充逻辑、输出分别封装为独立类（如 MatrixParser、FloodFillEngine），提升可测试性。

重构后，MatrixRefill 成为一个真正可实例化、可复用、可单元测试的组件。例如，你可以在 JUnit 中轻松编写如下测试：

@Test
void testMultipleInstances() {
    MatrixRefill m1 = new MatrixRefill();
    m1.run(new String[]{"K,K,K-Y,Y,M-M,M,M", "1,1", "S"});

    MatrixRefill m2 = new MatrixRefill();
    m2.run(new String[]{"A,B-C,D", "0,0", "X"}); // 彼此状态完全隔离
}

这才是 Java 面向对象编程的正确实践起点。

好了，本文到此结束，带大家了解了《静态方法转对象，提升代码可测试性》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！