方法可以可读并且更短吗？

Question

我写了这个方法：

private int maxSequence (char player , Cell c)
{
    int row = c.getRow();
    int col = c.getCol();
    int maxVert = 0;
    int maxHor = 0;
    int maxDiag = 0;

    if (player == 'O')
    { 

        for (int j = 0; j < _board[0].length; j++)
        {
            if ( (_board[col][row+j] == 'O') || (_board[col][row-j] == 'O') )
            {
                maxVert++;
            }

            if ( (_board[col+j][row] == 'O') || (_board[col-j][row] == 'O') )
            {
                maxHor++;
            }

            if ( (_board[col+j][row+j] == 'O') || (_board[col-j][row-j] == 'O') )
            {
                maxDiag++;
            }
        }
    }

    if (player == 'X')
    {
        for (int j = 0; j < _board[0].length; j++)
        {
            if ( (_board[col][row+j] == 'O') || (_board[col][row-j] == 'X') )
            {
                maxVert++;
            }

            if ( (_board[col+j][row] == 'O') || (_board[col-j][row] == 'X') )
            {
                maxHor++;
            }

            if ( (_board[col+j][row+j] == 'O') || (_board[col-j][row-j] == 'X') )
            {
                maxDiag++;
            }
        }
    }

    if ( (maxDiag >= maxVert) && (maxDiag >= maxHor) )
    {
        return maxDiag;
    }

    else if ( (maxVert >= maxDiag) && (maxVert >= maxHor) )
    {
        return maxVert;
    }

    else
    {
        return maxHor;
    }
}

我想知道是否有一种方法可以改进该方法以使其可读并且 \ 或更短？

Answer 1

使用 O 作为变量名是一个坏主意。 O 很容易被误读或误输入为 0，反之亦然，正如您在几个地方所做的那样。

在这种情况下，出于上述原因，我认为您应该使用诸如 O_PLAYER 和 O_MARKER 之类的内容来代替 O，并且还可以区分两者代码中常量的不同含义。 （事实上​​，根据更大的上下文，我可能为这两种情况创建了几个 enum 类型。）

将左花括号放在前一行可以节省空间，并且（IMO）就像可读；例如，

if (cond) {
   // blah
} else {
   // blah
}

使用

if (cond) 
{
   // blah
} 
else 
{
   // blah
}

_ 作为实例变量前缀违反了 Java 命名标准。

最后，最后 12 行可以重写为：

return Math.max(maxHor, Math.max(maxVert, maxDiag));

Answer 2

首先，您可能需要遵循 java 编码约定，尤其是命名方面（有意义的名称，没有下划线...）并且您还可以删除布尔值评估周围的额外括号，如下所示。

您还可以将 for 循环合并为一个，因为它们正在做真正相似的工作

if (board[col][row + j] == O || board[col][row - j] == O) 


        if (maxDiag >= maxVert && maxDiag >= maxHor) {
            return maxDiag;
        }else if (maxVert >= maxDiag && maxVert >= maxHor) {
            return maxVert;
        }else {
            return maxHor;
        }

Answer 3

除了这无法编译这一事实（除非 X 和 O 是实例变量）...

玩家“O”的代码与玩家“X”有何不同'？答案是每个 if 语句中的第二个表达式...将其替换为变量，然后您就将代码减半了。

然而，更好的方法是根本不使用这些条件。但这需要思考如何对棋盘上的任意位置进行 Tic-Tac-Toe AI 操作。

Answer 4

private int maxSequence (char player , Cell c)
{
    int row = c.getRow();
    int col = c.getCol();
    int maxVert = 0;
    int maxHor = 0;
    int maxDiag = 0;

    for (int j = 0; j < _board[0].length; j++)
    {
        if ( (_board[col][row+j] == O) || (_board[col][row-j] == player) )
        {
            maxVert++;
        }

        if ( (_board[col+j][row] == O) || (_board[col-j][row] == player) )
        {
            maxHor++;
        }

        if ( (_board[col+j][row+j] == 0) || (_board[col-j][row-j] == player) )
        {
            maxDiag++;
        }
    }

    return Math.max(maxDiag, Math.max(maxVert, maxHor));
}

Answer 5

在大多数情况下，构建复杂的单行代码并不是一个好主意。然而，在某些情况下，比如这里，你可以让眼睛很容易看到多行上的共同点和不同点：

private int maxSequence (char player , Cell c)
    {
        int row = c.getRow();
        int col = c.getCol();
        int maxVert = 0;
        int maxHor = 0;
        int maxDiag = 0;

        if (player == O)
        {
            for (int j = 0; j < _board[0].length; j++)
            {
                if ((_board [col]  [row+j] == O) || (_board [col]  [row-j] == O))  maxVert++;
                if ((_board [col+j][row]   == O) || (_board [col-j][row]   == O))  maxHor++;
                if ((_board [col+j][row+j] == 0) || (_board [col-j][row-j] == O))  maxDiag++;
            }
        }
        if (player == X)
        {
            for (int j = 0; j < _board[0].length; j++)
            {
                if ((_board [col]  [row+j] == O) || (_board [col]  [row-j] == X))   maxVert++;
                if ((_board [col+j][row]   == O) || (_board [col-j][row]   == X))   maxHor++;
                if ((_board [col+j][row+j] == 0) || (_board [col-j][row-j] == X))   maxDiag++;
            }
        }
        if ((maxDiag >= maxVert) && (maxDiag >= maxHor))    return maxDiag;
        if ((maxVert >= maxDiag) && (maxVert >= maxHor))    return maxVert;
        return maxHor;
    }

重新整理行后，我观察到在第一个块中，你测试了 OO,OO， OO，在 OX,OX,OX 的第二个块中，我怀疑，您想测试 XX,XX,XX。

如果没有编译，在第二个视图中我看到有一个 OO0，我期望有一个 OOO（不是 XXX，就像上面提到的那样）。 :) - 啊，但是这种模式也用在纯 O-Block 中。

我想补充一点，我喜欢 Stehpen C 表达 max(a, b, c) 的想法，前两个块应该替换为参数化块，并且整个程序的更大图片可能会导致完全不同的结果设计，更加面向对象。

结合这些建议，我们暂时停在这里：

private int maxSequence (char player, Cell c)
{
    int row = c.getRow();
    int col = c.getCol();
    int maxVert = 0;
    int maxHor = 0;
    int maxDiag = 0;

    for (int j = 0; j < _board[0].length; j++)
    {
        if ((board [col]  [row+j] == player) || (board [col]  [row-j] == player))  maxVert++;
        if ((board [col+j][row]   == player) || (board [col-j][row]   == player))  maxHor++;
        if ((board [col+j][row+j] == player) || (board [col-j][row-j] == player))  maxDiag++;
    }
    return Math.max (maxHor, Math.max (maxVert, maxDiag));
}

中间，因为我们可能会做一个完全不同的设计 - 我至少闻到了棋盘级和玩家级的味道。

Answer 6

这里不是完整的答案，抱歉，今天早上喝咖啡有点懒（这看起来也像学校的问题）。因此，我将保持高水平。

1. 不要害怕方法，它们可以大大提高清晰度。您的 for 循环可以封装在一个方法中，其中的名称解释了发生了什么。
2. 避免使用魔法值，用常量替换“X”字符。
3. 更好的是用玩家类包装角色。 Player.for('x') 返回一个玩家类。将循环中的行为委托给 XPlayer、YPlayer 类。
4. 就像其他海报指出的那样，尽可能使用 Math.max 和其他内置函数