Em Java, todas as exceções têm um ancestral comum, jogável (jogável). O Throwable especifica a semelhança de quaisquer problemas que possam ser transmitidos por meio de aplicativos Java no código por mecanismos de propagação de exceção.
O Throwable tem duas subclasses importantes: exceção e erro. Ambos são subclasses importantes para o manuseio de exceções de Java e cada um contém um grande número de subclasses.
①.Exception é um possível problema previsível e recuperável no aplicativo. Geralmente, a maioria das anormalidades indica problemas moderados a leves. As exceções geralmente são geradas em ambientes específicos e geralmente ocorrem em métodos e operações específicos do código. Na classe Echoinput, pode ocorrer uma ioexception ao tentar chamar o método ReadLine.
A classe de exceção tem uma subclasse importante, RuntimeException. A classe RuntimeTimeException e suas subclasses representam um erro levantado por "Operações de JVM comuns". Por exemplo, se você tentar usar uma referência de objeto nulo, o divisor zero ou a matriz dos limites, uma exceção de tempo de execução (NullPointerException, arithmeticexception) e ArrayIndexoutOfBoundException são levantados respectivamente.
②.Error indica um problema sério na execução do aplicativo. A maioria dos erros não está relacionada às ações executadas pelo escritor de código, mas representa problemas com a JVM (Java Virtual Machine) quando o código é executado. Por exemplo, quando a JVM não tiver mais os recursos de memória necessários para continuar a operação, um OrofMemoryError aparecerá.
A divisão entre verificar exceções e não verificações
Exceções em Java são divididas em duas categorias:
1. Exceção verificada (exceção não-runima)
2. Exceção conectada (exceção de tempo de execução)
Exceção de tempo de execução
A classe RunTimeException é uma subclasse da classe de exceção. É chamado de exceção de tempo de execução. Todas as exceções de tempo de execução no Java serão herdadas direta ou indiretamente da classe RuntimeException.
Quaisquer exceções em Java que herdem da exceção, mas não da RuntimeException, são exceções não intermediárias.
Uma tentativa pode ser seguida por várias capturas, mas não importa quantos, no máximo um bloco de captura serão executados.
Para exceções que não são de áreas, elas devem ser processadas, caso contrário, não poderão ser compiladas.
Existem duas maneiras de lidar com isso:
1. Use, tente..catch..finalmente para capturar;
2. Escreva um tipo de exceção de lança após a declaração do método que gera a exceção, como a exceção, faça a exceção à camada externa.
Para exceções de tempo de execução, eles podem ser processados ou não. Recomenda -se não lidar com exceções de tempo de execução.
Extensão: a diferença entre erro e exceção (erro vs exceção)
1) .java.lang.error: Uma subclasse de arremesso, usada para marcar erros críticos. Um aplicativo razoável não deve ir para tentar/pegar erros. A maioria dos erros é anormal e não deve acontecer.
java.lang.Exception: Uma subclasse de arremesso, usada para indicar um programa razoável para capturar. Ou seja, é apenas uma condição de execução do programa, não um erro grave, e os programas de usuário são incentivados a pegá -lo.
2). Erro e RunTimeException e suas subclasses são exceções desmarcadas, enquanto todas as outras classes de exceção são exceções verificadas.
Exceções verificadas: geralmente é lançado de um programa recuperável e é mais capaz de se recuperar de tais exceções usando o programa. Por exemplo, o FILENOTFOUNDEXCECTION, parseexception, etc. A exceção verificada ocorre no estágio de compilação e você deve usar tente ... captura (ou arremesso) ou a compilação não será passada.
Exceções desmarcadas: geralmente uma exceção que não deveria ter acontecido se tudo estiver normal, mas isso acontece. Ocorre durante o tempo de execução e tem incerteza, causada principalmente por problemas lógicos no programa. Por exemplo, ArrayIndexoutOfBoundException, ClassCastException, etc. Na perspectiva do próprio idioma, os programas não devem usar exceções como o Catch. Embora eles possam capturar e se recuperar de exceções como o RuntimeException, os programadores de terminais não são incentivados a fazer isso porque não há necessidade de fazê -lo. Como esse tipo de erro é um bug e deve ser corrigido, o programa deve ser interrompido imediatamente quando esses erros ocorrem. Portanto, diante de erros e exceções desmarcadas, o programa deve ser encerrado automaticamente. Os programadores não devem fazer coisas como tentar/capturar, mas devem descobrir o motivo e modificar a lógica do código.
RUNTimeException: O sistema RunTimeException inclui conversão de tipo incorreto, acesso fora dos limites, tentativas de acessar ponteiros nulos, etc.
O princípio do manuseio de tempo de execução é: se ocorrer uma tempo de execução, deve ser o erro de um programador. Por exemplo, as exceções de acesso à matriz fora dos limites podem ser evitadas por verificando os subscritos da matriz e os limites da matriz. Outras exceções (iooxception, etc.) são geralmente erros externos, como tentar ler dados do final do arquivo, etc. Isso não é um erro do próprio programa, mas um erro externo que ocorre no ambiente do aplicativo.
O artigo acima Java_Exception Class (Introdução à diferença entre erros e exceções) é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.