HexapawnBoard class in Java
<p>I have to complete 4 methods but I am having difficulty understanding them. I'm trying to complete <code>whitemove()</code>. I know that I have to iterate through the board, but I cannot totally understand how I'm supposed to do it!</p>

<pre><code>import java.util.List;
import java.util.ArrayList;

public class HexapawnBoard {
private static final int WHITE_PIECE = 1;
private static final int BLACK_PIECE = 2;
private static final int EMPTY = 0;

private static final int BOARD_SIZE = 3;

private int[][] board;

/**
 * Create a board position from a string of length BOARD_SIZE*BOARD_SIZE (9).
 * The first BOARD_SIZE positions in the string correspond to the black player's home
 * position. The last BOARD_SIZE positions in the string correspond ot the white player's
 * home position. So, the string "BBB   WWW" corresponds to a starting position.
 * 
 * @param pos the string encoding the position of the board
 */
public HexapawnBoard(String pos)
{
    if(pos.length() != BOARD_SIZE * BOARD_SIZE)
        throw new RuntimeException("HexapawnBoard string must be of length BOARD_SIZExBOARD_SIZE");

    board = new int[BOARD_SIZE][BOARD_SIZE];
    for(int row=0;row&lt;BOARD_SIZE;row++)
    {
        for(int col=0;col&lt;BOARD_SIZE;col++)
        {
            switch(pos.charAt(row*BOARD_SIZE+col))
            {
            case 'B':
            case 'b':
                board[row][col] = BLACK_PIECE;
                break;
            case 'W':
            case 'w':
                board[row][col] = WHITE_PIECE;
                break;
            case ' ':
                board[row][col] = EMPTY;
                break;
            default:
                throw new RuntimeException("Invalid Hexapawn board pattern " + pos);
            }
        }
    }
}

/**
 * A copy constructor of HexapawnBoard
 * 
 * @param other the other instance of HexapawnBoard to copy
 */
public HexapawnBoard(HexapawnBoard other)
{
    board = new int[BOARD_SIZE][BOARD_SIZE];
    for(int i=0;i&lt;BOARD_SIZE;i++)
        for(int j=0;j&lt;BOARD_SIZE;j++)
            this.board[i][j] = other.board[i][j];
}


/**
 * Return a string version of the board. This uses the same format as the 
 * constructor (above)
 * 
 * @return a string representation of the board.
 */
public String toString()
{
    StringBuffer sb = new StringBuffer();
    for(int row=0;row&lt;BOARD_SIZE;row++)
    {
        for(int col=0;col&lt;BOARD_SIZE;col++)
        {
            switch(board[row][col])
            {
            case BLACK_PIECE:
                sb.append('B');
                break;
            case WHITE_PIECE:
                sb.append('W');
                break;  
            case EMPTY:
                sb.append(' ');
                break;
            }
        }
    }
    return sb.toString();
}

/**
 * Determine if this board position corresponds to a winning state.
 * 
 * @return true iff black has won.
 */
public boolean blackWins()
{
    for(int col=0;col&lt;BOARD_SIZE;col++)
        if(board[BOARD_SIZE-1][col] == BLACK_PIECE)
            return true;
    return false;
}

/**
 * Determine if this board position corresponds to a winning state
 * 
 * @return true iff white has won
 */
public boolean whiteWins()
{
    for(int col=0;col&lt;BOARD_SIZE;col++)
        if(board[0][col] == WHITE_PIECE)
            return true;
    return false;
}

/**
 * Determine if black has a move
 * 
 * @ return truee iff black has a move
 */
public boolean blackCanMove()
{

    return false;
}

/**
 * Return a List of valid moves of white. Moves are represented as valid 
 * Hexapawn board positions. If white cannot move then the list is empty.
 * 
 * @return A list of possible next moves for white
 */
public List&lt;HexapawnBoard&gt; whiteMoves()
{
    return null
}

/**
 * Determine if two board positions are equal
 * @param other the other board position
 * @return true iff they are equivalent board positions
 */
public boolean equals(HexapawnBoard other)
{

    return true;
}

/**
 * Determine if two board positions are reflections of each other
 * @param other the other board position
 * @return true iff they are equivalent board positions
 */
public boolean equalsReflection(HexapawnBoard other)
{

    return true;
}

 }
</code></pre>
