Question

以下方法用于确定是否阻止棋子进行某一动作。在调用这个方法的时候，运动本身（即Bishop对角线移动的能力）已经被验证了 - 这个方法将会查看＆＃34;路径＆＃34;这件作品必须采取。

很明显，这种方法充满了冗余。事实上，有6个几乎相同的for循环，差异是1）哪些变量控制迭代，2）变量是递增还是递减，3），在对角线运动的情况下，包含一个同时递增/递减x和y变量的语句。

我已经多次尝试将这些语句抽象为一个单独的方法。不幸的是，限制因素需要访问电路板[y] [x] - 当我试图抽象逻辑时，我忽略了哪个变量代表y和哪个x。

所以，我的问题是：Java为我提供了哪些工具来抽象这个逻辑并减少或消除此方法中的冗余？我会指出我对这门语言很陌生，所以请不要因为故意或简单的钝而忽视常见的习语;我正在学习！

感谢。

private static boolean notBlocked(Piece[][] board, int xfrom, int yfrom, int xto, int yto) {

    int x = xfrom;
    int xstop = xto;
    int y = yfrom;
    int ystop = yto;

    int xinc = (x < xstop) ? 1 : -1;
    int yinc = (y < ystop) ? 1 : -1;

    Piece to = board[yto][xto];
    Piece from = board[yfrom][xfrom];

    if (xfrom == xto) {
        // x is constant, check in y direction
        if (y <= ystop) {
            for (; y <= ystop; y += yinc) {
                if (board[y][x] != null && board[y][x] != to && board[y][x] != from) {
                    return false;
                }
            }
        } else {
            for (; y >= ystop; y += yinc) {
                if (board[y][x] != null && board[y][x] != to && board[y][x] != from) {
                    return false;
                }
            }
        }
    } else if (yfrom == yto) {
        // y is constant, check in x direction
        if (x <= xstop) {
            for (; x <= xstop; x += xinc) {
                if (board[y][x] != null && board[y][x] != to && board[y][x] != from) {
                    return false;
                }
            }
        } else {
            for (; x >= xstop; x += xinc) {
                if (board[y][x] != null && board[y][x] != to && board[y][x] != from) {
                    return false;
                }
            }
        }
    } else if (Math.abs(xfrom - xto) == Math.abs(yfrom - yto)){
        // the move is diagonal
        if (y <= ystop) {
            for (; y <= ystop; y += yinc) {
                if (board[y][x] != null && board[y][x] != to && board[y][x] != from) {
                    return false;
                }
                x += xinc;
            }
        } else {
            for (; y >= ystop; y += yinc) {
                if (board[y][x] != null && board[y][x] != to && board[y][x] != from) {
                    return false;
                }
                x += xinc;
            }
        }
    }
    return true;
}

修改

哇...现在好多了！

private static boolean notBlocked(Piece[][] board, int xfrom, int yfrom, int xto, int yto) {

    Piece from = board[yfrom][xfrom];
    Piece to = board[yto][xto];

    // Determine the direction (if any) of x and y movement
    int dx = (xfrom < xto) ? 1 : ((xfrom == xto) ? 0 : -1);
    int dy = (yfrom < yto) ? 1 : ((yfrom == yto) ? 0 : -1);

    // Determine the number of times we must iterate
    int steps = Math.max(Math.abs(xfrom - xto), Math.abs(yfrom - yto));

    if (xfrom == xto || yfrom == yto || Math.abs(xfrom - xto) == Math.abs(yfrom - yto)) {
        for (int i = 1; i < steps; i++) {
            int x = xfrom + i * dx;
            int y = yfrom + i * dy;
            if (isBlocked(board, from, to, x, y)) {
                return false;
            }
        }
    }
    return true;
}

Answer 1

考虑按照正确方向的一步来编写此功能。假设您可以填写两个变量dx和dy，它们表示您在每个步骤的x和y方向上移动了多少。您可以通过查看开始和结束x和y位置之间的差异来计算此值。一旦你有了这个，你就可以写一个尝试沿着那个方向移动的for循环，检查每一步。例如：

for (int i = 1; i < numStepsRequired; i++) {
    int currX = x + i * dx;
    int currY = y + i * dy;
    if (board[currY][currX] != null) {
        return false;
    }
}

您还需要计算需要多少步骤，只要您计算dx和dy，这也是很简单的。我将把它留作练习，因为这是一个很好的编程实践。

希望这有帮助！

如何抽象出这个片段的逻辑？

1 个答案: