Duvida com try catch

Programação
#1

Boa Noite
Estou fazendo um programa e sei que em alguma parte do código vai dar java.lang.ArrayIndexOutOfBoundsException(Preciso Ignorar), tentei usar um try cath mas depois que cai na exceção ele não volta a executar o restante, consegui resolver colocando um try catch para cada expressão que poderia dar errado,mas acredito que tenha alguma forma mais fácil de fazer.

public void setarSensaçoes() {
		for (int x = 0; x <= 3; x++) {
			for (int y = 0; y <= 3; y++) {
				if (caverna[x][y] == ouro) {
					try {
						caverna[x][y + 1] |= cintilancia;
						caverna[x][y - 1] |= cintilancia;
						caverna[x - 1][y] |= cintilancia;
						caverna[x + 1][y] |= cintilancia;
					} catch (Exception e) {

					}
                }
}
}
}

Solução Temporária:

public void setarSensaçoes() {
		for (int x = 0; x <= 3; x++) {
			for (int y = 0; y <= 3; y++) {
				if (caverna[x][y] == ouro) {
					try {
						caverna[x][y + 1] |= cintilancia;
						// caverna[x][y - 1] |= cintilancia;
						// caverna[x - 1][y] |= cintilancia;
						// caverna[x + 1][y] |= cintilancia;
					} catch (Exception e) {

					}

					try {

						caverna[x][y - 1] |= cintilancia;

					} catch (Exception e) {

					}
					try {

						caverna[x - 1][y] |= cintilancia;

					} catch (Exception e) {

					}
					try {

						caverna[x + 1][y] |= cintilancia;

					} catch (Exception e) {

					}
				}
			}

		}

	}
#2

Sei que cada um tem sua necessidade, mas acredito que ignorar não é o melhor caminho.

A forma mais fácil de fazer é justamente impedindo que esta exception ocorra.

A cada iteração do loop vc precisa acessar o elemento atual, o anterior e o próximo, certo? Logo podemos concluir que o tamanho de caverna tem que ser no mínimo 3 x 3.

Se o tamanho for exatamente 3 x 3, então não há necessiDade de loop. Simplesmente faça assim:

public void setarSensaçoes() {
    caverna[0][0] |= cintilancia;
    caverna[0][1] |= cintilancia;
    caverna[0][2] |= cintilancia;
    caverna[1][0] |= cintilancia;
    caverna[1][1] |= cintilancia;
    caverna[1][2] |= cintilancia;
    caverna[2][0] |= cintilancia;
    caverna[2][1] |= cintilancia;
    caverna[2][2] |= cintilancia;
}

Para os casos em que o tamanho é de 4 x 4 pra cima, vc teria que organizar seu loop da seguinte forma:

  • x e y começam em 1 e não em 0
  • o loop deve funcionar enquanto x < caverna.length - 1 e y < caverna[0].length - 1

Eu fiz um exemplo:

class Main {
    static final int a = 5;
    static final int b = 5;

    static int[][] caverna = new int[a][b];
    static int ouro = 1;
    static int cintilancia = 2;

    static void print(int x, int y) {
        System.out.printf("x[%d] = %d, x[%d] = %d, x[%d] = %d\n",
                x, caverna[x][y], x - 1, caverna[x - 1][y], x + 1, caverna[x + 1][y]);

        System.out.printf("y[%d] = %d, y[%d] = %d, y[%d] = %d\n",
                y, caverna[x][y], y - 1, caverna[x][y - 1], y + 1, caverna[x][y + 1]);

        caverna[x][y]         |= cintilancia;
        caverna[x][y + 1]     |= cintilancia;
        caverna[x][y - 1]     |= cintilancia;
        caverna[x - 1][y]     |= cintilancia;
        caverna[x - 1][y + 1] |= cintilancia;
        caverna[x - 1][y - 1] |= cintilancia;
        caverna[x + 1][y]     |= cintilancia;
        caverna[x + 1][y + 1] |= cintilancia;
        caverna[x + 1][y - 1] |= cintilancia;
    }


    public static void setarSensaçoes() {
        if (a > 3 && b > 3) {
            for (int x = 1; x < caverna.length - 1; x++) {
                for (int y = 1; y < caverna[0].length - 1; y++) {
                    // aqui vc pode sempre acessar o elemento anterior e o próximo com segurança
                    print(x, y);
                }

                System.out.println();
            }
        } else if (a > 2 && b > 2) {
            print(1, 1);
        }
    }

    public static void main(String[] args) {
        setarSensaçoes();
    }
}

Este código não lança exceptions, o único problema que resta é se for permitido a matriz ter dimensões diferentes tipo 3 x 4.

Qualquer coisa explicar melhor esse problema e mostra o restante do código, tenho quase certeza de que evitar a exception é o melhor caminho no seu caso.

#3

Na verdade o que estou fazendo é um trabalho do jogo Wumpus, nesse jogo quando o ouro está um uma casa ele emite uma luz para as outras casas, Ex:

image

image

o “Tabuleiro” é uma matriz 4x4,a casa que o ouro vai aparecer quando começa o jogo é determinada por um x e y randomicamente, então teria que adicionar o valor luz nas casas adjacentes como mostra a imagem acima, entretanto nem sempre ele estará em uma posição que atenda as 4 expressões o que vai ocasionar o java.lang.ArrayIndexOutOfBoundsException.

#4

Entendi. Que interessante.

Acredito que vc não precisa do loop então.

Minha implementação ficou assim:

import java.util.Arrays;

class Main {
    private static void print(int x, int y) {
        final String[][] matrix = new String[4][4];
        final Position[] lights = new Position[4];

        for (String[] row : matrix) Arrays.fill(row, "----");

        Position gold = new Position(x, y);
        lights[0] = new Position(gold.x - 1, gold.y);
        lights[1] = new Position(gold.x + 1, gold.y);
        lights[2] = new Position(gold.x, gold.y - 1);
        lights[3] = new Position(gold.x, gold.y + 1);

        matrix[gold.x][gold.y] = "gold";

        for (Position light: lights)
            if (light.isInsideBounds()) matrix[light.x][light.y] = "light";

        for (int i = 0; i < 4; i++)
            System.out.printf("%5s %5s %5s %5s\n", matrix[i][0], matrix[i][1], matrix[i][2], matrix[i][3]);

        System.out.println("\n=======================\n");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 4; i++)
            for (int j = 0; j < 4; j++)
                print(i, j);
    }

    static class Position {
        final int x, y;
        Position(int x, int y) {
            this.x = x;
            this.y = y;
        }

        boolean isInsideBounds() {
            return x >= 0 && y >= 0 && x < 4 && y < 4;
        }
    }
}

Criei uma classe só pra representar a posição. Essa classe tem um método que diz se aquela posição está dentro dos limites da matriz.

O resto fica mais facil.

#5

Você pode testar as posições.

public void setarSensaçoes() {
    for (int x = 0; x <= 3; x++) {
        for (int y = 0; y <= 3; y++) {
            if (caverna[x][y] == ouro) {
                if (posicaoValida(x, y + 1)) {
                    caverna[x][y + 1] |= cintilancia;
                }
                if (posicaoValida(x, y - 1)) {
                    caverna[x][y - 1] |= cintilancia;
                }
                if (posicaoValida(x - 1, y)) {
                    caverna[x - 1][y] |= cintilancia;
                }
                if (posicaoValida(x + 1, y)) {
                    caverna[x + 1][y] |= cintilancia;
                }
            }
        }
    }
}

O método posicaoValida pode ser implementado assim:

private boolean posicaoValida(int x, int y) {
    if (x < 0) {
        return false;
    }
    if (y < 0) {
        return false;
    }
    if (x >= caverna.length) {
        return false;
    }
    if (y >= caverna[x].length) {
        return false;
    }
    return true;
}

Ou assim:

private boolean posicaoValida(int x, int y) {
    try {
        int valor = caverna[x][y];
        return true;
    } catch (IndexOutOfBoundsException e) {
        return false;
    }
}