Simple way to ignore out of bounds exceptions JAVA

Do yourself a favor and create model.countUnturnedMinesAround(i,j). Then inside model you have some options.

You can create extra rows/columns that view does not see so that you can sfely handle off-by-one indexes.

Or you can write a function private Cell getCell(i,j) that would return default empty cell when i and j are out of bound.

Or you can have boolean hasUnturnedMine(i,j) that returns false when i or j are off the grid.

You can avoid duplication with loops:

for (int iOffset = -1; iOffset <= 1; iOffset++) {
    for (int jOffset = -1; jOffset <= 1; jOffset++) {
        if (iOffset != 0 || jOffset != 0) {
            if (isInGrid(i + iOffset, j + jOffset) && 
                model.get(i + iOffset, j + jOffset) == MinerGridCo.UNTURNED_MINE) {
                    count++;
            }
        }
    }
}

using the isInGrid function suggested by @Emrakul's answer (I'd actually combine the range check and the UNTURNED_MINE check into one hasUnturnedMine function, as mentioned in @Arkadiy's answer).

Create a one line function:

boolean checkBounds(int i, int j) { //TODO }

Then check that before doing your model lookup

An alternative approach could be to have a method isBorder(int i, int j) that lets you know if you're on the bounds. If it is not a border, you know you can safely check all squares around (i,j). If it is on the border, you can calculate whether it's a left/right/top/bottom border or some combination of the 4 (no more than 2) and then check the appropriate boxes.

disclaimer: I am assuming you're already doing a check to make sure (i,j) is a valid location on the grid. You should be doing a check for this regardless of your implementation

There are better ways to do this, via structuring your code a little better. However Here's the answer to your specific question:

The way you ignore an exception in Java is with a try-catch block. This allows you to attempt to run a block of code, catch any exceptions which get thrown, and then decide what to do about them (including ignore them).

Assuming that your out of bounds exception is coming from the model.get() calls you could ignore them like this:

int count = 0;
try
{
    if(model.get(i-1, j-1) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i, j-1) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i-1, j) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i+1, j) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i, j+1) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i-1, j+1) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i+1, j-1) == MinerGridCo.UNTURNED_MINE){ count++;}
    if(model.get(i+1, j+1) == MinerGridCo.UNTURNED_MINE){ count++;}
}
catch (IndexOutOfBoundsException ex)
{
    // Do nothing
}
String mineNum = String.valueOf(count);
cell[i][j].setText(mineNum);

However, when an exception is encountered all subsequent code in the try block will be skipped. And this is definitely not what you want because you'll miss checking some adjacencies. Instead you will need to perform a try-catch for each call to model.get(). This is best implemented by creating a boolean function like:

// Change method visibility and signature accordingly to match your code
public static boolean tileHasMine(int x, int y)
{
    try
    {
        if (model.get(x, y) == MinerGridCo.UNTURNED_MINE)
        {
            return true;
        }
    }
    catch (IndexOutOfBoundsException ex)
    {
        // Do Nothing
    }
    return false;
}

Then your checks would look like:

int count = 0;
if(tileHasMine(i-1, j-1)){ count++;}
if(tileHasMine(i, j-1)){ count++;}
if(tileHasMine(i-1, j)){ count++;}
if(tileHasMine(i+1, j)){ count++;}
if(tileHasMine(i, j+1)){ count++;}
if(tileHasMine(i-1, j+1)){ count++;}
if(tileHasMine(i+1, j-1)){ count++;}
if(tileHasMine(i+1, j+1)){ count++;}
String mineNum = String.valueOf(count);
cell[i][j].setText(mineNum);

Alternatively, you could write a boolean function that first checks if the block is out of the bounds of the model prior to even trying to read from it, which may be a better approach. But I think this is what you were asking.