Olá! Na última palestra, conhecemos um aspecto da linguagem Java como exceções e vimos exemplos de como trabalhar com elas. Hoje daremos uma olhada mais profunda em sua estrutura e também aprenderemos como escrever nossas próprias exceções :)
Tipos de exceções
Como dissemos, existem muitas classes de exceção em Java, quase 400! Mas eles estão todos divididos em grupos, por isso é muito fácil lembrá-los. Isto é o que parece: Todas as exceções têm uma classe ancestral comumThrowable
. Dele surgem dois grandes grupos - exceções (Exceção) e erros (Erro). Erro é um erro crítico durante a execução do programa associado à operação da máquina virtual Java. Na maioria dos casos, Error não precisa ser tratado, pois indica algumas falhas graves no código. Os erros mais famosos: StackOverflowError
- ocorre, por exemplo, quando um método chama a si mesmo indefinidamente, e OutOfMemoryError
- ocorre quando não há memória suficiente para criar novos objetos. Como você pode ver, nessas situações, na maioria das vezes não há nada de especial para processar - o código está simplesmente escrito incorretamente e precisa ser refeito. As exceções são, na verdade, exceções: uma situação excepcional e não planejada que ocorreu durante a execução do programa. Estes não são erros tão graves como o Error, mas requerem a nossa atenção. Todas as exceções são divididas em 2 tipos - verificadas ( marcadas ) e não verificadas ( desmarcadas ). Todas as exceções verificadas vêm do arquivo Exception
. O que significa “verificável”? Mencionamos isso parcialmente na última palestra : “...o compilador Java conhece as exceções mais comuns e sabe em que situações elas podem ocorrer”. Por exemplo, ele sabe que se um programador lê dados de um arquivo em código, pode facilmente surgir a situação de o arquivo não existir. E há muitas situações que ele pode prever com antecedência. Portanto, o compilador verifica nosso código antecipadamente em busca de possíveis exceções. Se os encontrar, não compilará o código até que os processemos ou encaminhemos para o topo. O segundo tipo de exceção é “desmarcado”. Eles vêm da classe RuntimeException
. Como eles diferem daqueles que estão sendo testados? Parece que também existem várias classes diferentes que vêm RuntimeException
e descrevem exceções específicas de tempo de execução. A diferença é que o compilador não espera esses erros. Ele parece estar dizendo: “No momento em que escrevi o código, não encontrei nada suspeito, mas algo deu errado enquanto ele funcionava. Aparentemente há erros no código!” E de fato é. As exceções não verificadas são geralmente o resultado de erros do programador. E o compilador claramente não é capaz de fornecer todas as situações incorretas possíveis que as pessoas podem criar com suas próprias mãos :) Portanto, ele não verificará o tratamento de tais exceções em nosso código. Você já encontrou várias exceções não verificadas:
ArithmeticException
ocorre quando dividido por zeroArrayIndexOutOfBoundsException
Ocorre ao tentar acessar uma célula fora do array.
Como lançar sua exceção
É claro que os criadores de Java não são capazes de prever todas as situações excepcionais que podem surgir nos programas. Existem muitos programas no mundo e eles são muito diferentes. Mas tudo bem, porque você pode criar suas próprias exceções, se necessário. Isso é feito com muita facilidade. Tudo que você precisa fazer é criar sua própria classe. Seu nome deve terminar com “Exceção”. O compilador não precisa disso, mas os programadores que lerem seu código entenderão imediatamente que se trata de uma classe de exceção. Além disso, você precisa indicar que a turma vem da turmaException
. Isso já é necessário para o compilador e correto funcionamento. Por exemplo, temos uma classe Dog - Dog
. Podemos passear com o cachorro usando o walk()
. Mas antes disso, precisamos verificar se nosso animal de estimação está usando coleira, guia e focinheira. Se algum deles estiver faltando, lançaremos nossa própria exceção DogIsNotReadyException
. Seu código ficará assim:
public class DogIsNotReadyException extends Exception {
public DogIsNotReadyException(String message) {
super(message);
}
}
Para indicar que uma classe é uma exceção, você precisa escrever extends Exception após o nome da classe: isso significa que “a classe deriva da classe Exception”. No construtor, simplesmente chamaremos o construtor da classe Exception
com uma linha message
- ela exibirá ao usuário uma mensagem do sistema descrevendo o erro ocorrido. Esta é a aparência do 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("Let's go for a walk!");
if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
System.out.println("Hurrah, let's go for a walk!" + name + " I am glad!");
} else {
throw new DogIsNotReadyException("Dog " + name + "not ready for a walk! Check your gear!");
}
}
}
Agora nosso método walk()
lança uma exceção DogIsNotReadyException
. Isso é feito usando a palavra-chave throw
. Como dissemos anteriormente, uma exceção é um objeto. Portanto, em nosso método, quando ocorre uma situação excepcional - algo está faltando no cachorro - criamos um novo objeto de classe DogIsNotReadyException
e o lançamos no programa usando a palavra throw
. walk()
Adicionamos lançamentos à assinatura do método DogIsNotReadyException
. Em outras palavras, o compilador agora sabe que uma chamada de método walk()
pode resultar em uma exceção. Portanto, quando chamarmos isso em algum lugar do programa, a exceção precisará ser tratada. Vamos tentar fazer isso no método main()
:
public static void main(String[] args) {
Dog dog = new Dog("Mukhtar");
dog.putCollar();
dog.putMuzzle();
dog.walk();//Unhandled exception: DogIsNotReadyException
}
Não compila, exceção não tratada! Vamos agrupar nosso código em um bloco try-catch
para tratar a exceção:
public static void main(String[] args) {
Dog dog = new Dog("Mukhtar");
dog.putCollar();
dog.putMuzzle();
try {
dog.walk();
} catch (DogIsNotReadyException e) {
System.out.println(e.getMessage());
System.out.println("Checking equipment! Is the collar on?" + dog.isCollarPutOn + "\r\n Is the leash on?"
+ dog.isLeashPutOn + "\r\n Are you wearing a muzzle?" + dog.isMuzzlePutOn);
}
}
Agora vamos dar uma olhada na saída do console:
Ошейник надет!
Намордник надет!
Собираемся на прогулку!
Собака Мухтар не готова к прогулке! Проверьте экипировку!
Проверяем снаряжение! Ошейник надет? true
Поводок надет? false
Намордник надет? true
Veja como a saída do console se tornou muito mais informativa! Vemos cada etapa que aconteceu no programa; Vemos onde o erro ocorreu e imediatamente percebemos o que exatamente está faltando em nosso cachorro :) É assim que criamos nossas próprias exceções. Como você pode ver, nada complicado. E embora os desenvolvedores Java não tenham se preocupado em adicionar uma exceção especial à sua linguagem para cães equipados incorretamente, corrigimos seu descuido :)
GO TO FULL VERSION