Java: exceções e seu manuseio

Qualquer programa funcionará de forma estável somente se seu código fonte for depurado e não houver condições que possam causar situações imprevistas. O processo de captura de possíveis falhas é realizado na fase de programação. Para fazer isso, o desenvolvedor leva em consideração todos os resultados esperados e tenta limitar o efeito do erro para que ele não possa quebrar o programa ou levar ao seu colapso.

Quando você precisará lidar com exceções

Em Java, as exceções podem ser causadas por entrada incorreta do usuário, falta do recurso necessário para executar o programa ou uma desconexão repentina da rede. Para o uso confortável do aplicativo criado pelo desenvolvedor, é necessário controlar a ocorrência de situações extraordinárias. O consumidor não deve aguardar o programa suspenso para completar seu trabalho, perder dados como resultado de exceções não tratadas, ou simplesmente as mensagens que aparentemente aparecem que algo deu errado.

Manipulação de Exceções Java

O que deve ser considerado? A linguagem Java possui a funcionalidade de gerenciamento de exceções embutida. Claro, uma grande porcentagem de erros são capturados no estágio de compilação, quando o sistema informará automaticamente que não pode ser usado mais. Mas há também um tipo de exceções que ocorrem durante a operação do programa. O desenvolvedor deve ser capaz de prever isso e projetar o código de forma que não cause erros, mas o trata de forma especial ou passa o controle para outro ramo.

Em Java, tal captura de exceções é imposta pelo compilador, então os problemas típicos são conhecidos e têm seu próprio esquema de execução padrão.

Exceções típicas

O exemplo mais simples em que você pode obter uma exceção é a divisão. Apesar de toda sua simplicidade, na expressão, como divisor, pode haver zero, o que levará a um erro. Bem, se sua aparência pode ser predita anteriormente e prevenida. Mas esta opção nem sempre está disponível, portanto, é necessário organizar a exceção de captura imediatamente se ocorrer uma "divisão por zero".

Em Java, o mecanismo de tratamento de erros parece assim:

• No heap, um objeto de exceção é criado, assim como qualquer outro;
• O curso natural do programa é interrompido;
• O mecanismo de exceção tenta encontrar uma maneira alternativa de continuar o código;
• Encontrando o local da execução segura do programa no manipulador, o trabalho será restaurado, ou uma exceção será implementada de forma especial.

O exemplo mais simples de criar um erro pode parecer assim:

Se (a == nulo)

Jogue novo NullPointerException ();

Aqui, a variável a é verificada para a inicialização, ou seja, Não é igual à referência nula. No caso em que esta situação ocorre e o processamento especial é necessário, uma exceção é lançada com o lançamento do novo NullPointerException ().

Alguns detalhes sobre palavras-chave

Ao trabalhar com exceções, muitas vezes você precisa usar palavras-chave Java para se referir a uma ação. Há cinco deles nesta linguagem de programação:

• Tente. Esta palavra – chave já foi encontrada e significa que ele está indo para uma seção de código que pode lançar uma exceção. O bloco é limitado a braçadeiras curvas {}.
• Pegar. Ele gera o tipo de exceção apropriado e processa-o de acordo.
• Finalmente. Esta palavra-chave é opcional e serve para executar um código que é necessário em qualquer caso, mesmo que nenhuma exceção seja interceptada. É adicionado imediatamente após o bloco try.
• Throw – permite que você crie exceções Java em qualquer lugar do código.
• Throws é uma palavra-chave que é colocada na assinatura do método. Isso significa que o código subsequente pode descartar a exceção de Java do tipo especificado. Este rótulo serve como um sinal para os desenvolvedores, o que você precisa ter em mente – o método pode não funcionar como esperado.

Pegue com a tentativa

O lançamento na exceção Java, naturalmente pressupõe que ele será tratado de maneira especial. A maneira mais conveniente para fazer isso é se a seção de código for particionada em um bloco. O que possivelmente contém uma exceção. Ao executar esse código, a máquina virtual encontra uma situação inesperada, entende que está no bloqueio crítico e transfere o controle para a área de processamento.

Em Java, o código está envolvido em um bloco de tentativa especial, dentro do qual uma exceção pode ser lançada. Assim, várias situações imprevistas são colocadas nele, que serão capturadas em um só lugar, sem se arrastar ao longo do código.

O código mais típico com um bloco de processamento parece assim:

Tente {

// Isso determinará o código que pode lançar uma exceção

} Captura (Extração_1_1 identificador_1) {

// Aqui a exceção é processada, de acordo com seu tipo e condições;

} Catch (Extraction_type_2 identifier_2) {

// Aqui a exceção é processada, de acordo com seu tipo e condições;

}

A palavra-chave catch informa que o código submetido à verificação de exceção deve ser processado conforme descrito abaixo, desde que corresponda ao seu tipo. O identificador pode ser usado dentro do bloco de código de processamento como argumentos.

Finalmente

Como ficou claro no capítulo anterior, pegar bloqueios e capturar exceções e processá-los. Mas muitas vezes há uma situação em que algum código deve ser executado, independentemente de os erros serem detectados. Para isso, a palavra final existe. Ele é usado para aumentar os valores de vários contadores, fechar arquivos ou conexões para a rede.

Nesta seção, existem vários blocos de captura com métodos inventados de capturar exceções. Por exemplo, o código contido na tentativa gera uma situação inesperada do tipo Cold. Então, as expressões "Travou frio!" E "Isso é algo para animar?" Será exibido no console. Ou seja, o último bloco é executado em qualquer caso.

Na verdade, existe uma maneira de evitar a execução definitiva. Está relacionado ao término da máquina virtual. Descubra como isso pode ser feito na Internet.

A palavra-chave throw

Throw lança uma exceção. Sua sintaxe parece assim:

Throw New NewException ();

Aqui, uma nova exceção é criada com o tipo NewException (). Como um tipo, você pode usar classes já incluídas nas bibliotecas Java padrão e definidas anteriormente pelo desenvolvedor de sua própria produção.

Essa construção está incluída na descrição de qualquer método, cuja chamada deve então ocorrer dentro do bloco try, para poder interceptá-lo.

Lances de palavras-chave

O que fazer se no processo de desenvolvimento existe uma situação em que o método pode lançar uma exceção, mas não pode lidar com isso corretamente. Para fazer isso, a assinatura do método especifica a palavra lances e o tipo de possível exceção.

Este rótulo é um tipo de ponteiro para os desenvolvedores de clientes que o método não é capaz de processar sua própria exceção. Além disso, se o tipo de erro for verificável, o compilador explicitamente o especificará.

Tente com recursos

Na versão 7 de Java, os desenvolvedores incluíram uma inovação tão importante quanto o processamento do bloco try com recursos.

Muitos dos objetos criados em Java, após o uso deles, devem ser fechados para economizar recursos. Anteriormente, você precisava contabilizar e parar essas instâncias manualmente. Agora eles têm uma interface AutoClosable. Isso ajuda a fechar automaticamente objetos já usados, colocados no bloco try. Graças a essa abordagem, tornou-se mais conveniente escrever o código, sua legibilidade aumentou significativamente.

Classes de exceção Java personalizadas

Os criadores da linguagem de programação descrita levaram em conta muitos aspectos ao projetar tipos de situações imprevistas. No entanto, todas as variantes do resultado dos eventos não podem ser evitadas, portanto, em Java, é possível determinar suas próprias exceções adequadas às necessidades de um código específico.

A maneira mais simples de criar é herdar do objeto mais apropriado para o contexto.

Aqui você herdou da Exceção, uma classe que é usada para definir suas próprias exceções. Na MyException há dois construtores – um por padrão, o segundo – com o argumento do tipo msg String.

Então, na classe pública FullConstructors, o método f é implementado, cuja assinatura contém lances MyException. Esta palavra-chave significa que f pode lançar uma exceção Java do tipo MyException. Além disso, no corpo do método, as informações de texto são enviadas para o console e a geração real do MyException, via throw.

O segundo método é ligeiramente diferente do primeiro em que, quando uma exceção é lançada, um parâmetro de string é passado para ele, que será refletido no console quando ele for capturado. Em geral, você vê que f () e g () são colocados no bloco try e a palavra-chave catch é definida para capturar MyException. O resultado do processamento é a saída da mensagem de erro para o console:

Assim, foi possível adicionar exceções Java criadas por sua própria mão.

Arquitetura de Exceção

Como todos os objetos em Java, as exceções também são herdadas e possuem uma estrutura hierárquica. O elemento raiz de todos os erros lançados nesta linguagem de programação é a classe java.lang.Throwable. Ele herda dois tipos – Erro e Exceção.

Erro – notifica sobre erros críticos e representa exceções Java não verificadas. A intercepção e processamento de tais dados na maioria dos casos ocorre no estágio de desenvolvimento e não precisa ser implementado no código da aplicação final.

A classe mais utilizada para criar e analisar exceções é Exception. O que, por sua vez, é dividido em vários ramos, incluindo o RuntimeException. RuntimeException refere-se a exceções de tempo de execução, ou seja, aquelas que ocorrem enquanto o programa está sendo executado. Todas as classes herdadas dela não são verificáveis.

Exceções comuns

Nas exceções de Java, a lista de quais são apresentadas abaixo, são usadas na maioria das vezes, por isso vale a pena descrever cada uma delas com mais detalhes:

• ArithmeticException. Isso inclui erros relacionados a operações aritméticas. O exemplo mais marcante é a divisão por zero.
• ArrayIndexOutOfBoundsException – acesso ao número do elemento da matriz que excede seu comprimento total.
• ArrayStoreException – uma tentativa de atribuir um elemento de matriz de um tipo incompatível.
• ClassCastException é uma tentativa de interpretar mal um tipo para outro.
• IllegalArgumentException – uso de um argumento inválido na chamada de método.
• NegativeArraySizeException é uma exceção ao criar uma matriz de tamanho negativo.
• NullPointerException – uso incorreto da referência nula.
• NumberFormatException – ocorre quando a string não é convertida em um número.
• UnsupportedOperationException – a operação não é suportada.

Esses exemplos são tipos não descartados de exceções Java. E assim verifique:

• ClassNotFoundException – classe não encontrada.
• IllegalAcccessException – restringindo o acesso à classe.
• InterruptedException – interrupção do fluxo.
• NoSuchFieldException – o campo necessário não existe.

Interpretação de exceções

Falando em exceções comuns, deve-se notar que sua interpretação durante o desenvolvimento pode ser confundida. Em seguida, há uma pequena lista explicando com mais detalhes quando uma situação imprevista pode surgir.

NullPointerException. A primeira vez que ocorre uma exceção é referir-se a uma referência de objeto que é nula. Isso também se aplica aos métodos da instância zero da classe. Uma NullPointerException pode ser lançada e se o comprimento da matriz for igual a nulo. Evite tais situações ao verificar periodicamente os objetos em nulo.

ArrayIndexOutOfBoundsException. Qualquer programa não pode existir sem usar arrays. Consequentemente, uma referência frequente a eles pode gerar erros. Ocorre uma exceção quando o desenvolvedor tenta acessar um elemento de matriz que não está na lista de índice. Por exemplo, o valor solicitado está acima do comprimento ou menor que zero. Isso geralmente aparece como resultado do fato de que a contagem na matriz começa a partir de zero.

Conclusões

Gerenciamento de exceção O Java é uma poderosa ferramenta de meio ambiente que facilita muito o trabalho do programador e permite que ele crie um código limpo e sem erros. O status e a reputação da empresa de desenvolvedores dependem de quão limpa e estável seja a aplicação.

Claro, em programas mais ou menos simples, é muito mais fácil acompanhar as situações freelance. Mas em grandes complexos automatizados por várias centenas de mil linhas, isso só é possível como resultado da depuração e teste de longo prazo.

Para exceções de Java, erros que surgem em algumas aplicações, as empresas individuais oferecem recompensas quando são entusiastas. Especialmente apreciados são aqueles que causam violação da política de segurança do complexo de software.