Criando Exceções Java Personalizadas

Introdução

Em Java, as exceções são lançadas para indicar eventos excepcionais que ocorrem durante a execução de um programa. Embora o Java forneça uma gama de exceções embutidas, às vezes podemos precisar definir nossas próprias exceções personalizadas para situações específicas. Existem dois tipos de exceções personalizadas: exceções verificadas (checked exceptions) e não verificadas (unchecked exceptions). Exceções verificadas são aquelas que precisam ser tratadas durante o tempo de compilação, enquanto exceções não verificadas são detectadas apenas durante o tempo de execução. Neste laboratório, criaremos ambos os tipos de exceções personalizadas e aprenderemos como usá-las.

Criar uma Classe Java Chamada MyArray

Primeiramente, criaremos uma classe Java chamada MyArray para implementar um array com o método get(), que pode lançar uma exceção se o índice for inválido.

public class MyArray {
    int[] array;

    public MyArray(int size) {
        array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i * 5;
        }
    }

    // Get method that may throw an exception
    public int get(int index) {
        if (index >= array.length) {
            throw new IndexOutOfBoundsException("Index " + index + " is invalid.");
        } else {
            return array[index];
        }
    }
}

Criar uma Exceção Verificada Personalizada

Podemos criar uma exceção verificada personalizada estendendo a classe Exception. Neste exemplo, criaremos uma IndexNotValidException quando o índice for inválido. Esta exceção será lançada pelo método get() na classe MyArray.

public class IndexNotValidException extends Exception {
    public IndexNotValidException(String message) {
        super(message);
    }
}

Agora podemos atualizar o método get() na classe MyArray para lançar esta exceção personalizada.

public int get(int index) throws IndexNotValidException {
    if (index >= array.length) {
        throw new IndexNotValidException("Index " + index + " is invalid.");
    } else {
        return array[index];
    }
}

Lidar com a Exceção Verificada Personalizada

Para lidar com a exceção verificada personalizada, precisamos capturá-la (catch) ou declará-la usando a palavra-chave throws quando o método get() é chamado na classe Demo.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        try {
            System.out.println(arr.get(10)); // Throws IndexNotValidException
        } catch (IndexNotValidException e) {
            System.err.println(e.getMessage());
        }
    }
}

Criar uma Exceção Não Verificada Personalizada

Podemos criar uma exceção não verificada personalizada estendendo a classe RuntimeException em vez da classe Exception. No exemplo a seguir, criaremos uma IndexNotValidRuntimeException quando o índice for inválido, que será lançada pelo método get() na classe MyArray.

public class IndexNotValidRuntimeException extends RuntimeException {
    public IndexNotValidRuntimeException(String message, Throwable cause) {
        super(message, cause);
    }
}

Além disso, definimos uma exceção lançável (throwable exception) que define a exceção subjacente ou a causa da nossa exceção. No nosso caso, a exceção subjacente é ArrayIndexOutOfBounds. Podemos atualizar o método get() na classe MyArray para lançar a exceção não verificada personalizada.

public int get(int index) {
    if (index >= array.length) {
        Throwable cause = new ArrayIndexOutOfBoundsException();
        throw new IndexNotValidRuntimeException("Index " + index + " is invalid.", cause);
    } else {
        return array[index];
    }
}

Lidar com a Exceção Não Verificada Personalizada

Não precisamos capturar (catch) ou declarar a exceção não verificada personalizada. No exemplo a seguir, quando o método get() é chamado com um índice inválido na classe Demo, uma IndexNotValidRuntimeException será lançada.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        System.out.println(arr.get(10)); // Throws IndexNotValidRuntimeException
    }
}

Resumo

Exceções Java personalizadas podem nos ajudar a lidar com erros ou exceções específicas em nossa aplicação de forma eficaz, criando exceções que são adaptadas às nossas necessidades. Neste laboratório, aprendemos como criar nossas próprias exceções personalizadas para lidar com erros em nossa lógica de negócios ou fluxo de trabalho. Também discutimos como criar exceções verificadas (checked exceptions) e não verificadas (unchecked exceptions), com exemplos de cada uma.