递归实现二维数组列乘指定值后逐行求和的Java代码改造

我尝试将数组的每个 "column（列）" 乘以 特定数值，再对每个 "row（行）" 的计算结果求和。
我已经实现了单一维数组场景下的该逻辑，但在处理 2d-array（二维数组） 时遇到了困难。
实现要求：必须递归实现，不能使用循环，需要基于已有的一维数组代码改造出适配二维数组的版本。

原有一维数组实现代码如下：

public static int didIt(int[] d, int n) {        
    //base or terminating condition
    if (n <= 0) {
        return 0;
    }
    if (n == 1) {
        return didIt(d, n - 1) + d[n - 1] * 10;
    }
    if (n == 2) {
        return didIt(d, n - 1) + d[n - 1] * 50;
    }
    if (n == 3) {
        return didIt(d, n - 1) + d[n - 1] * 22;
    }
    if (n == 4) {
        return didIt(d, n - 1) + d[n - 1] * 7;
    }
    if (n == 5) {
        return didIt(d, n - 1) + d[n - 1] * 45;
    } else {
        return didIt(d, n - 1) + d[n - 1];
    }
}

public static void main(String[] args) {
    int[] array2 = {1, 2, 3, 4, 5};
    System.out.println(didIt(array2, array2.length));
}

• 二维数组的递归处理拆为两层逻辑：第一层递归负责逐行遍历二维数组，第二层直接复用已有的一维数组行计算逻辑，不需要修改原有列乘数规则
• 两层递归的终止条件统一为「待处理的索引超出对应数组长度」，触发时返回0作为累加基准值
• 逐行累加时，当前行的计算结果与剩余行的递归返回值相加，逐层向上传递结果，最终得到总和

public class RecursiveArrayCalc {
    // 原有一维数组（单行）计算逻辑，完全保留无需修改
    public static int didIt(int[] d, int n) {        
        // 递归终止条件：所有列处理完成
        if (n <= 0) {
            return 0;
        }
        if (n == 1) {
            return didIt(d, n - 1) + d[n - 1] * 10;
        }
        if (n == 2) {
            return didIt(d, n - 1) + d[n - 1] * 50;
        }
        if (n == 3) {
            return didIt(d, n - 1) + d[n - 1] * 22;
        }
        if (n == 4) {
            return didIt(d, n - 1) + d[n - 1] * 7;
        }
        if (n == 5) {
            return didIt(d, n - 1) + d[n - 1] * 45;
        } else {
            return didIt(d, n - 1) + d[n - 1];
        }
    }

    // 新增二维数组递归处理方法
    public static int didIt2D(int[][] d, int currentRow) {
        // 递归终止条件：所有行处理完成
        if (currentRow >= d.length) {
            return 0;
        }
        // 计算当前行的列加权和，叠加剩余行的递归计算结果
        int rowSum = didIt(d[currentRow], d[currentRow].length);
        return rowSum + didIt2D(d, currentRow + 1);
    }

    public static void main(String[] args) {
        // 原有一维数组测试
        int[] array1D = {1, 2, 3, 4, 5};
        System.out.println("一维数组计算结果：" + didIt(array1D, array1D.length));

        // 二维数组测试
        int[][] array2D = {
                {1, 2, 3, 4, 5},
                {6, 7, 8, 9, 10}
        };
        // 从第0行开始递归处理
        System.out.println("二维数组计算结果：" + didIt2D(array2D, 0));
    }
}

• 调用didIt2D时传入二维数组和起始行索引0，首先校验当前行索引是否超出数组总行数，超出则返回0终止递归
• 索引合法时，取出当前行对应的一维数组，调用原有didIt方法，按既定列系数计算当前行的加权和
• 将当前行的和，与「行索引+1后递归调用didIt2D得到的剩余行总和」相加，作为当前层的返回值向上传递
• 整个实现全程未使用任何循环语句，完全符合递归实现要求

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