如何避免在Java矩阵填充代码中使用静态方法与静态变量？

我正在做Java课程的往届考题，现在碰到个难题——运行代码总是出错误结果。我猜是因为代码里所有成员变量和方法都用了静态，想知道怎么避免用静态？

题目要求：找到args[1]指定位置的字符，把所有相邻的相同字符替换成"S"（示例参数："K,K,K,Y-K,Y,M,M-K,Y,Y,Y 2,1 S"）。

我的代码如下：

public class MatrixRefill {
    public static String[][] matrix;
    public static int rows;
    public static int cols;
    public static String enemy;      
    public static String target;        
    public static void main(String[] args) {
        target = args[2];
        rows = Integer.parseInt(args[1].substring(0,1));
        cols = Integer.parseInt(args[1].substring(2));
        matrix = matrixCreator(args[0]);
        enemy = matrix[rows][cols];
        recursive(rows, cols, target);
        printer(matrix);
    }
    public static String[][] matrixCreator(String mx) {
        int ro = 0;
        int co = 0;
        for (int i = 0; i < mx.length(); i++) {
            if (mx.substring(i,i+1).equals(","))
                co++;
            if (mx.substring(i,i+1).equals("-"))
                ro++;
        }
        String[][] matriks = new String[ro+1][co/3+1];
        ro = 0;
        co = 0;
        for (int j = 0; j < mx.length(); j++) {
            if (mx.substring(j,j+1).equals(","))
                co++;
            else if (mx.substring(j,j+1).equals("-")) {
                ro++;
                co = 0;
            }
            else
                matriks[ro][co] = mx.substring(j,j+1);
        }
        return matriks;
    }   
    public static void recursive(int row, int col, String target) {
        if (valid(row,col)) {
            recursive(row+1,col, target);
            recursive(row,col+1, target);
            recursive(row,col-1, target);
            recursive(row-1,col, target);
            matrix[row][col] = target;
        }
    }
    public static boolean valid(int row, int col) {
        boolean result = false;
        if (row >= 0 && row < matrix.length && col >= 0 && col < matrix[row].length)
            if (matrix[row][col] == enemy)
                result = true;
        return result;
    }
    public static 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();
        }
    }   
}

一、移除静态的核心步骤 #

把类改成实例化使用的结构，让变量和方法属于对象而非类本身，步骤如下：

1. 将静态成员变量改为实例变量
   去掉static修饰符，这些变量是每个MatrixRefill对象的专属状态：

   public class MatrixRefill {
       private String[][] matrix;
       private int targetRow; // 原rows，改名更清晰
       private int targetCol; // 原cols
       private String enemy;      
       private String target;
       // ...
   }
   

2. 添加构造方法初始化对象状态
   把原来main里的初始化逻辑移到构造方法，接收必要参数完成初始化：

   public MatrixRefill(String matrixStr, String targetPos, String replaceStr) {
       target = replaceStr;
       // 解析目标位置，用split比substring更通用
       String[] pos = targetPos.split(",");
       targetRow = Integer.parseInt(pos[0]);
       targetCol = Integer.parseInt(pos[1]);
       // 创建矩阵
       matrix = matrixCreator(matrixStr);
       // 获取目标字符
       enemy = matrix[targetRow][targetCol];
   }
   

3. 将静态方法改为实例方法
   去掉方法的static修饰符，直接使用实例变量，无需重复传参：

   private void recursive(int row, int col) {
       if (valid(row, col)) {
           // 先标记为目标值，避免重复递归（原代码的关键bug）
           matrix[row][col] = target;
           recursive(row+1, col);
           recursive(row, col+1);
           recursive(row, col-1);
           recursive(row-1, col);
       }
   }
   
   private boolean valid(int row, int col) {
       // 先判断边界
       if (row < 0 || row >= matrix.length || col < 0 || col >= matrix[row].length) {
           return false;
       }
       // 字符串必须用equals比较内容，不能用==
       return matrix[row][col].equals(enemy);
   }
   

4. 重构main方法
   在main里创建对象，调用实例方法完成业务逻辑：

   public static void main(String[] args) {
       if (args.length != 3) {
           System.out.println("参数格式错误：需要矩阵字符串、目标位置、替换字符");
           return;
       }
       MatrixRefill refill = new MatrixRefill(args[0], args[1], args[2]);
       refill.recursive(refill.targetRow, refill.targetCol);
       refill.printer();
   }
   

5. 修改printer方法
   直接打印实例的matrix，无需额外传参：

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

二、原代码的其他关键错误（导致结果异常） #

1. 字符串比较用==而非equals
   Java中==比较的是对象引用，不是字符串内容，必须改成matrix[row][col].equals(enemy)。

2. 递归顺序错误
   原代码先递归相邻位置再修改当前值，会导致同一个位置被多次递归处理，应该先修改当前值再递归，避免重复操作。

3. 矩阵创建逻辑不可靠
   原代码通过统计逗号数量计算列数的逻辑依赖每行逗号数固定，改用split方法更稳定：

   private String[][] matrixCreator(String mx) {
       String[] rowStrs = mx.split("-");
       String[][] matriks = new String[rowStrs.length][];
       for (int i = 0; i < rowStrs.length; i++) {
           matriks[i] = rowStrs[i].split(",");
       }
       return matriks;
   }
   

内容的提问来源于stack exchange，提问作者Arson1st