Does Java have a const reference equivalent?

Question

Here's a snippet of code:

    //Game board is made up of Squares.  A player can place GamePieces on a Square.
    public class CheckersBoard
    {
        public boolean PlaceGamePiece(GamePiece gamePiece, int nRow, int nColumn) {
            return m_theGameBoard[nRow][nColumn].PlaceGamePiece(gamePiece);
        }

        private Square[][] m_theGameBoard;
    }

Let say I'm testing the PlaceGamePiece method (using junit) and I need to access the m_theGameBoard so I can look at it and verify the GamePiece was placed on the correct Square and has the correct data.

In C++ I'd either make the test class a friend so it can access the private member m_theGameBoard, or I'd have a function that returns a const GameBoard that cannot be modified (because it's const):

const GameBoard& GetGameBoard() const { return m_theGameBoard; }

Now I can do what ever checking I want to do on the game board, but I can't modify the game board because it's const.

Java doesn't support returning const references or friend classes. So my question is what is the standard Java way of doing this?? Do I have to just provide a bunch of get accessors that allow me check the data on the Square?

UPDATE: I ended up writing a GetPiece method as Kaleb Brasee suggested.

public GamePiece GetGamePiece(Point pt) {
    return new GamePiece(m_theGameBoard[pt.GetRow()][pt.GetColumn()]);
}

Notice I create a new GamePiece object and return that. I'm not returning the GameBoards internal reference, therefore no one can modify the gameboard because they only have a copy! Nice! Thanks for the help guys, some really good advice.

FYI: I keep changing the names of the objects when I post them on here, sorry if that confused anyone.

Answer 1

Yes - your choices basically boil down to either having

Square getSquareAtLocation(int row, int col) { ... };

or using one of the Java collections which you could then pass through Collections.unmodifiableList(...)

(note that if you used a multidimensional List, you'd have to be careful to wrap the inner Lists as well to make sure they're not modifiable either)

If this is only ever going to be used for testing, you could also create a function that returns a deep copy of the array.

Answer 2

Apply the principle of Tell, Don't Ask.

Example

Consider:

public class Board {
  private Piece[][] board;

  public Board() {
  }

  public void put( Piece piece, int x, int y ) {
    Piece[][] board = getBoard();
    board[x][y] = piece;
  }

  public void remove( int x, int y ) {
    put( null, x, y );
  }

  public boolean hasPiece( PieceType pieceType, int x, int y ) {
    Piece[][] board = getBoard();
    Piece piece = board[x][y];

    return piece != null && piece.isType( pieceType );
  }

  private Piece[][] getBoard() {
    return this.board;
  }
}

Unit Testing

Unit testing then takes very little effort:

public class Test {
  public static void main( String args[] ) {
    Board board = new Board();
    board.put( new KnightPiece(), 5, 5 );

    assertTrue( board.hasPiece( KnightPieceType, 5, 5 ) );
  }
}

Detailed Example

Review an API for a Go game board for details.

Answer 3

You could define the variable as protected, so that if the unit test is in the same package, it can access it.

However, I would just add a public method getPiece(int row, int col) that returns the piece on that square (or null if there's no piece there). It's likely you'll need a method like that anyway, and you could use it in your tests.

Answer 4

The default access modifier for a method or property is "package-protected", which means "visible only within my package". Therefore, you can emulate the semantics of "friendship", while maintaining a separate code base for tests, by having two distinct source folders, but with the same package structure.

src
|--com
    |
    --cchampion
         |
         --MyClass.java
tests
|--com
    |
    --cchampion
         |
         --TestMyClass.java

Then, within MyClass.java

public class MyClass {
    private int nonTestedThing;
    int[][] testedThing;  // this is visible to TestMyClass
    // or
    // protected int[][] testedThing;
    // if you want it visible to kids
}

Not ideal in any respect, but it's one way to go about it.