Sempre existem vários problemas no programa. Para ativar a operação normal durante a execução do programa, o mecanismo de manuseio de exceção fornecido pelo Java é usado para capturar possíveis exceções, exceções e permitir que o programa seja executado normalmente. Este é o manuseio de exceção de Java.
1. Exceções captáveis
Exceções que podem ser capturadas em Java são divididas em exceções controláveis e de tempo de execução.
1. Exceções controláveis
No Java, esses erros previsíveis podem ser processados durante a compilação do programa e informações específicas de erro podem ser fornecidas. Esses erros são chamados de exceções controláveis. Exceções controláveis comumente usadas são as seguintes:
Exceção Descrição IoException Quando ocorre uma exceção de E/S, essa exceção é lançada. O SQLEXCIPCECTION fornece informações sobre erros de acesso ao banco de dados ou outros erros. ClassNotFoundException. A exceção não é encontrada. NosuchfieldException. O sinal gerado quando a classe não contém um campo com o nome especificado. NosuchmethodException. A exceção é lançada.
2. Exceção de tempo de execução
Os erros que não podem ser detectados pelo compilador em Java são chamados exceções de tempo de execução. Exceções comuns de tempo de execução são as seguintes:
Exception Description IndexOutOfBoundsException Indicates that the exception is thrown when the index value of a collection or array is out of range NullPointerException throws the exception when the application tries to use null where the object is needed ArithmeticException throws this exception when an exception operation condition occurs IllegalArgumentException throws an exception indicating that an illegal or incorrect parameter is passed to the method ClassCastException throws the exception when trying to cast the object to uma subclasse que não é uma instância
2. Lidar com exceções
Quando ocorre uma exceção em Java, você pode usar ... Experimente, tente ... pegue ... finalmente ou tente ... finalmente para lidar com isso.
1. Use tente .... captura para lidar com exceções
Após a tentativa, existem declarações que executam normalmente e, após a captura, há declarações que lidam com exceções. Os colchetes da captura são os tipos de exceção que o programa precisa lidar. O formato de sintaxe é o seguinte:
tente {declarações que executam normalmente} catch (exceção e) {declarações que lidam com exceções}Aqui está um exemplo de exceção aritmética, como segue.
classe pública ExceptionTest {public static void main (string [] args) {int resultado = 1/0; tente {System.out.println (resultado); } catch (Exceção e) {System.out.println ("Exceção de arremesso:" + e.getMessage ()); }}}Aqui 1/0 é um algoritmo de exceção porque o divisor não pode ser 0. Os resultados da operação são os seguintes:
Como há uma exceção, a declaração após tentativa não é executada, portanto a declaração após a captura é executada. Entre eles, "E.GetMessage ()" é um método para obter informações de exceção, que são usadas para obter seqüências detalhadas de mensagens; Além disso, existe também o método PrintStackTrace (), usado para produzir seu rastreamento de pilha para um fluxo de erro padrão; e o método ToString () é usado para obter uma breve descrição.
2. Use tente. pegar. Finalmente lide com exceções
Aqui, as declarações após a tentativa e a captura são as mesmas que as antes, e as declarações depois de finalmente precisam ser executadas, independentemente de ocorrer uma exceção. Portanto, o bloco de declaração finalmente é geralmente usado para executar a coleta de lixo. O formato de sintaxe é o seguinte:
tente {declarações que executam normalmente} catch (Exceção e) {declarações que lidam com exceções} finalmente {declarações que serão definitivamente processadas}3. Use tente. Finalmente lide com exceções
Quando ocorre uma exceção no programa, ele pode ser processado de acordo com o bloco de declaração finalmente. Além disso, quando não há exceção no programa, depois de executar a declaração entre tentativa e, finalmente, o código no bloco de instrução finalmente será executado. O formato de sintaxe é o seguinte:
tente {declarações que precisam ser executadas} finalmente {declarações que definitivamente serão processadas}3. Jogue uma exceção
Para exceções que ocorrem no programa, além do processamento de instrução TENT OBT OUVENTE, você também pode usar a declaração de arremessos ou lança a declaração para lançar exceções.
1. Uso lança a declaração para lançar a exceção
Os arremessos são usados para a declaração do método, lança uma exceção ao declarar um método usando a declaração de arremesso e, em seguida, lida com a exceção ao chamar o método.
Se você precisar declarar várias exceções, cada exceção deve ser separada por vírgulas, e o formato de sintaxe é o seguinte:
Nome do método do tipo de dados (lista formal de parâmetros) lança a classe 1 da Exception 1, classe de exceção 2, ..., classe de exceção n {body;}}Por exemplo, jogue uma exceção de exceção usando lances.
public void showInfo () lança Exceção {// Exceção FileInputStream in = new FileInputStream ("c: //record.txt"); // Crie objeto io}2. Use a declaração de arremesso para lançar a exceção
Se você deseja que o programa faça uma exceção por conta própria, pode usar a instrução THON para alcançá -la. O formato de sintaxe é o seguinte: lançar uma nova exceção ("exceção");
O que é lançado usando a instrução THON é uma instância da classe de exceção, geralmente usada com a instrução IF. como:
if (x <0) {lança nova exceção ("Exceção do programa, x não pode ser menor que 0.");}