Han Shunping aprendeu Java em 30 dias sem base [Capítulo 10 Anormal]

P444～P459

Início rápido, com.exception_.exception01.java

package com.exception_;
public class exception01 {
    public static void main(String[] args) {
        int num1=10;
        int num2=0;
        try {
            int res=num1/num2;
        } catch (Exception e) {
            e.printStackTrace();//java.lang.ArithmeticException: / by zero
            System.out.println(e.getMessage());/// by zero
        }
        System.out.println("程序继续执行");
    }
}
//因为num2=0，程序就会抛出异常 ArithmeticException
//当抛出异常程序就退出，下面的代码不执行

Na linguagem Java, as situações anormais que ocorrem durante a execução do programa são chamadas de exceções.

eventos anormais são divididos em

Erro:

Problemas sérios que a máquina virtual Java não consegue resolver. Tais como: erros internos do sistema JVM, esgotamento de recursos e outras situações graves.

Por exemplo: StackOverflowError [estouro de pilha] e OOM (sem memória), o erro é um erro grave, o programa travará

Exceção:

Outros problemas gerais causados por erros ou fatores externos acidentais podem ser tratados com códigos específicos. Por exemplo, acesso de ponteiro nulo, tentativa de ler um arquivo que não existe, interrupção de conexão de rede, etc., a exceção é dividida em duas categorias: exceção de tempo de execução e exceção de tempo de compilação

Exceções comuns de tempo de execução

NullPointerException: exceção de ponteiro nulo

Lançado quando um aplicativo tenta usar nulo onde um objeto é esperado
ArithmeticException: exceção de operação matemática
ArrayIndexOutOfBoundsException: exceção fora dos limites do subscrito do array

Exceção lançada ao acessar um array com um índice ilegal. Um índice é um índice ilegal se for negativo ou maior ou igual ao tamanho do array
ClassCastException: tipo de exceção de conversão

Lançado quando é feita uma tentativa de lançar um objeto para uma subclasse que não é uma instância
NumberFormatException: o formato do número não é a exceção correta

Quando um aplicativo tenta converter uma string para um tipo numérico, mas a string não pode ser convertida para o formato apropriado, usando exceções, podemos garantir que a entrada seja um valor numérico

String name = "1234";
//将String转int
int num = Integer.parseInt(name);

String name2 = "a";
int num2 = Integer.parseInt(name2);//NumberFormatException

Exceções comuns de compilação

SQLException: Ao operar o banco de dados, pode ocorrer uma exceção na tabela de consulta
IOException: Ocorreu uma exceção ao operar um arquivo
FileNotFoundException: Ao operar um arquivo que não existe, ocorre uma exceção
ClassNotFoundException: Ao carregar uma classe que não existe
EOFException: operação robusta, final de arquivo alcançado
IllegalArguementException: exceção de argumento

manipulação de exceção

O tratamento de exceções é a maneira de lidar com exceções quando ocorre uma exceção

A maneira como as exceções são tratadas

tente-pegar-finalmente

Pegue a exceção no código e trate você mesmo

try{
  可能有异常代码
}catch(Exception e){
  捕获到异常
  //当异常发生时，系统将异常分装成Exception对象e，传递给catch
  //程序员可以自己处理异常
  //如果try中没有发生异常，则catch代码块不执行
}finally{
  //不管try代码块中是否有异常发生，始终要执行finally
  //通常将释放资源的代码放在finally中
}

lances

Lança a exceção que ocorre e a entrega ao responsável pela chamada (método) para processamento. O manipulador de nível superior é a JVM

JVM 调用 main
main 调用 f1()
f1() 调用 f2()
f2()代码块发生异常，
f2可以用try-catch，或抛出给上一级
f2抛出异常，throws到f1，
f1可以用try-catch，或抛出给上一级
f1抛出异常，throws到main，
main可以用try-catch，或抛出给上一级
main抛出异常，throws到JVM，
JVM输出异常信息，退出程序

Escolha um dos try-catch e arremessos

Se o programador não manipular explicitamente a exceção, o padrão lançará

tentativa de captura

Java fornece blocos try e catch para lidar com exceções, blocos try são usados para conter código que pode dar errado e blocos catch são usados para lidar com exceções que ocorrem em blocos try

try{
  //可疑代码
  //将异常生成对应异常对象传递给catch块
}catch(异常){
  //对异常进行处理
}
//没有finally语法可以通过

detalhe

Se ocorrer uma exceção, o código por trás da exceção não será executado e entrará diretamente no bloco catch
Se a exceção não ocorrer, os blocos de código de try serão executados sequencialmente e o catch não será inserido
Se você deseja executar um determinado trecho de código, independentemente da ocorrência de uma exceção, use finalmente
Pode haver várias instruções catch para capturar diferentes exceções. É necessário que a exceção da classe pai seja seguida pela exceção da subclasse. Por exemplo, Exception deve ser seguido por NullPointerException. Se ocorrer uma exceção, apenas uma captura será correspondida.
Pode ser usado em conjunto com try-finally.Se houver uma exceção, o programa falhará, mas sempre será executado emfinal.Independentemente de ocorrer uma exceção, a lógica de negócios emfinalmente deve ser executada.

lança tratamento de exceção

Se um método pode gerar algum tipo de exceção, mas não tem certeza de como lidar com a exceção, o método deve declarar explicitamente que a exceção foi lançada, indicando que o método não tratará essas exceções, e o responsável pela chamada do método é por lidar com eles
Use a instrução throws no método para declarar a lista de exceções lançadas. O tipo de exceção por trás de throws pode ser o tipo de exceção gerado no método ou sua classe pai

detalhe

Para exceções de compilação, elas devem ser tratadas no programa, usando try-catch ou throws
Para exceções de tempo de execução, se não houver processamento no programa, o método padrão throws é processado
Quando a subclasse substitui o método da classe pai, as regras para lançar exceções: o tipo de exceção lançado pelo método reescrito pela subclasse é o mesmo que a exceção lançada pela classe pai ou o tipo de exceção lançada pelo Subtipo da classe pai
No processo de throws, se houver um método try-catch, é equivalente a tratar exceções, e throws não são necessários

exceção personalizada

Quando ocorrem alguns erros no programa, mas a informação do erro não está na subclasse de Throwable, você pode customizar a exceção

Classe de definição: nome da classe de exceção personalizada, herdar Exception ou RuntimeException
Se você herdar Exception, é uma exceção de compilação e a exceção de compilação deve ser exibida e processada
Se você herdar RuntimeException, é uma exceção em execução e geralmente é transformada em uma exceção em execução. A vantagem é que você pode usar o mecanismo de processamento padrão