Exceções: marcado, desmarcado e personalizado

Oi! Na última lição, conhecemos as exceções da linguagem Java e vimos exemplos de como trabalhar com elas. Hoje vamos dar uma olhada mais profunda na estrutura de exceções e aprender como escrever nossas próprias exceções :)

Tipos de exceções

Como dissemos anteriormente, existem muitas exceções em Java, quase 400! Mas eles estão todos divididos em grupos, por isso é bastante fácil lembrá-los. É assim que fica: Todas as exceções têm um ancestral comum na Throwableclasse. Dois grandes grupos são derivados dele: exceções ( Exception ) e erros ( Error ). Erro - Isso representa um erro crítico de tempo de execução relacionado à operação da máquina virtual Java. Na maioria dos casos, Error não precisa ser tratado, pois indica alguma falha grave no código. Os mais famosos são StackOverflowError (isso ocorre, por exemplo, quando um método chama a si mesmo indefinidamente) e OutOfMemoryError(isso ocorre quando não há memória suficiente para criar novos objetos). Como você pode ver, nessas situações, geralmente não há absolutamente nada para manipular em tempo de execução: o código é simplesmente escrito incorretamente e precisa ser retrabalhado. Exceção - Isso representa, bem, uma exceção: uma situação excepcional, não planejada, que ocorre durante a execução do programa. Eles não são tão sérios quanto o Error, mas ainda assim requerem nossa atenção. Todas as exceções são divididas em 2 tipos: marcadas e desmarcadas . Todas as exceções verificadas são derivadas da Exceptionclasse. O que significa "verificado"? Aludimos a isso na última lição: "O compilador Java, portanto, conhece as exceções mais comuns e as situações em que elas podem ocorrer." Por exemplo, ele sabe que se o código ler dados de um arquivo, o arquivo pode facilmente não existir. E existem muitas dessas situações (que podem ser inferidas). Da mesma forma, o compilador verifica nosso código antecipadamente quanto à presença dessas possíveis exceções. Se os encontrar, não compilará o código até que os tenhamos manipulado ou relançado. O segundo tipo de exceção é "desmarcado". Eles são derivados da RuntimeExceptionclasse. Como eles são diferentes das exceções verificadas? Parece que também existem muitas classes diferentes derivadas deRuntimeException(que descrevem exceções de tempo de execução). A diferença é que o compilador não antecipa esses erros. Parece estar dizendo: "Quando o código foi escrito, não encontrei nada suspeito, mas algo deu errado durante a execução. Aparentemente, há erros no código!" E de fato isso é verdade. As exceções não verificadas geralmente são o resultado de erros do programador. E o compilador obviamente não pode prever todas as situações ruins possíveis que as pessoas podem criar com suas próprias mãos. :) Portanto, ele não verifica se tais exceções são tratadas em nosso código. Você já encontrou várias exceções não verificadas:

• Ocorre uma ArithmeticException ao dividir por zero
• Um ArrayIndexOutOfBoundsException ocorre quando você tenta acessar uma posição fora do array.

Claro, você pode imaginar que os criadores de Java poderiam ter introduzido o tratamento de exceção obrigatório, mas neste caso o código seria muito complicado. Para qualquer operação de divisão, você teria que escrever um try-catchbloco para verificar se acidentalmente dividiu por zero? Sempre que você acessasse um array, teria que escrever um try-catchbloco para verificar se seu índice estava fora dos limites. Tudo seria código espaguete e seria completamente ilegível. Faz sentido que essa ideia tenha sido abandonada. Como resultado, as exceções não verificadas não precisam ser tratadas em try-catchblocos ou relançadas (embora isso seja tecnicamente possível, como no Error).

Como lançar sua própria exceção

Claro, os criadores de Java não podem prever todas as situações excepcionais que podem surgir nos programas. Existem muitos programas no mundo e eles são muito diversos. Mas isso não é motivo de preocupação, porque você pode criar sua própria exceção, se necessário. Isso é muito fácil de fazer. Tudo o que você precisa fazer é criar sua própria classe. Você deve ter certeza de que seu nome termina com "Exception". O compilador não exige isso, mas outros programadores que lerem seu código entenderão imediatamente que é uma classe de exceção. Além disso, indique que a classe é herdada da Exceptionclasse (o compilador exige isso). Por exemplo, suponha que temos uma Dogclasse. Podemos passear com o cachorro usando owalk()método. Mas antes de fazer isso, precisamos verificar se nosso animal de estimação está usando coleira, trela e focinheira. Se alguma dessas engrenagens estiver faltando, lançamos nossa própria exceção: DogIsNotReadyException . Seu código se parece com isso:

public class DogIsNotReadyException extends Exception {

   public DogIsNotReadyException(String message) {
       super(message);
   }
}

Para indicar que a classe é uma exceção, você precisa escrever " extends Exception " após o nome da classe (isso significa "a classe é derivada da classe Exception"). No construtor, simplesmente chamamos o Exceptionconstrutor da classe com a mensagem String (caso ocorra a exceção, mostraremos a mensagem, uma descrição do erro, para o usuário). Veja como isso fica em nosso código de classe:

public class Dog {

   String name;
   boolean isCollarPutOn;
   boolean isLeashPutOn;
   boolean isMuzzlePutOn;


   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

   }

   public void putCollar() {

       System.out.println("The collar is on!");
       this.isCollarPutOn = true;
   }

   public void putLeash() {

       System.out.println("The leash is on!");
       this.isLeashPutOn = true;
   }

   public void putMuzzle() {
       System.out.println("The muzzle is on!");
       this.isMuzzlePutOn = true;
   }

   public void walk() throws DogIsNotReadyException {

   System.out.println("We're getting ready for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hooray, let's go for a walk! " + name + " is very happy!");
   } else {
       throw new DogIsNotReadyException(name + " is not ready for a walk! Check the gear!");
   }
 }

}

Agora nosso walk()método lança um DogIsNotReadyException . Isso é feito com a palavra-chave throw. Como dissemos anteriormente, uma exceção é um objeto. Assim, quando ocorre uma exceção (o cachorro está perdendo alguma coisa) em nosso método, criamos um novo DogIsNotReadyExceptionobjeto e o lançamos usando a palavra-chave throw. Adicionamos " throws DogIsNotReadyException " à declaração do método. Em outras palavras, agora o compilador está ciente de que chamar o walk()método pode se tornar uma situação excepcional. Assim, esta exceção deve ser tratada se chamarmos este método em algum lugar do nosso programa. Vamos tentar fazer isso no main()método:

public static void main(String[] args) {
  
   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();// Unhandled exception: DogIsNotReadyException
}

Isso não vai compilar. A exceção não é tratada! Envolvemos nosso código em um try-catchbloco para lidar com a exceção:

public static void main(String[] args) {

   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   try {
       dog.walk();
   } catch (DogIsNotReadyException e) {
       System.out.println(e.getMessage());
       System.out.println("Checking the gear! Is the collar on? " + dog.isCollarPutOn + "\r\n Is the leash on? "
       + dog.isLeashPutOn + "\r\n Is the muzzle on? " + dog.isMuzzlePutOn);
   }
}

Agora vamos ver a saída do console: O colar está ligado! A focinheira está ligada! Estamos nos preparando para um passeio! Buddy não está pronto para uma caminhada! Verifique a engrenagem! Verificando a engrenagem! A coleira está colocada? true A coleira está colocada? false O focinho está ligado? true Veja como a saída do console era muito mais informativa! Vemos cada passo dado no programa; vemos onde ocorreu o erro e também podemos ver imediatamente exatamente o que nosso cachorro está perdendo. :) E é assim que você cria suas próprias exceções. Como você pode ver, não há nada complicado nisso. E mesmo que os criadores do Java não tenham se preocupado em incluir na linguagem uma exceção especial para cães mal equipados, corrigimos o descuido deles. :)