Vantagens das exceções na língua de programação de Java

Uma exceção é um evento, que ocorra durante a execução de um programa, que disrupts o fluxo normal das instruções de programa.

Vantagem 1: Separação Erro-Segurando o código do código "regular"

As exceções fornecem os meios separar os detalhes de o que fazer quando algo fora do ordinário acontece da lógica principal de um programa. Na programação tradicional, a deteção de erro, o relatório, e a manipulação conduzem frequentemente a código desconcertante do espaguete. Para o exemplo, considere o método do pseudocode aqui que lê uma lima inteira na memória:

readFile {
abra a lima;
determine seu tamanho;
aloce que muita memória;
leia a lima na memória;
feche a lima;
}

No primeiro glance, esta função parece simples bastante, mas ignora todos os seguintes erros potenciais:

• Que acontece se a lima não puder ser aberta?

• Que acontece se o comprimento da lima não puder ser determinado?

• Que acontece se bastante memória não puder ser alocada?

• Que acontece se lido falhar?

• Que acontece se a lima não puder ser closed?

Para segurar tais casos, a função readFile deve ter mais código para fazer a deteção de erro, relatando, e segurando. Está aqui um exemplo de o que a função pôde olhar como:

errorCodeType readFile {
inicialize o errorCode = 0;

abra a lima;
se (theFileIsOpen) {
determine o comprimento da lima;
se (gotTheFileLength) {
aloce que muita memória;
se (gotEnoughMemory) {
leia a lima na memória;
se (readFailed) {
errorCode = -1;
}
} mais {
errorCode = -2;
}
} mais {
errorCode = -3;
}
feche a lima;
se (== 0 do errorCode do && do theFileDidntClose) {
errorCode = -4;
} mais {
errorCode = errorCode e -4;
}
} mais {
errorCode = -5;
}
errorCode do retorno;
}

Há assim muita deteção de erro, relatando, e retornando aqui que as sete linhas originais do código estão perdidas na desordem. Mais mau ainda, o fluxo lógico do código foi perdido também, assim fazendo o difícil de dizer se o código está fazendo a coisa direita: A lima está sida realmente closed se a função não alocar bastante memória? É mesmo mais difícil assegurar-se de que o código continue a fazer a coisa direita quando você modifica o método três meses após a escrita ele. Muitos programadores resolvem este problema simplesmente ignorando iterrors são relatados quando seus programas deixam de funcionar.

As exceções permitem-no de escrever o fluxo principal de seu código e de tratar em outra parte dos casos excepcionais. Se a função readFile usasse exceções em vez das técnicas tradicionais da erro-gerência, olharia mais como o seguinte:

readFile {
tentativa {
abra a lima;
determine seu tamanho;
aloce que muita memória;
leia a lima na memória;
feche a lima;
} prendedor (fileOpenFailed) {
doSomething;
} prendedor (sizeDeterminationFailed) {
doSomething;
} prendedor (memoryAllocationFailed) {
doSomething;
} prendedor (readFailed) {
doSomething;
} prendedor (fileCloseFailed) {
doSomething;
}
}

Anote que as exceções não o poupam o esforço de fazer o trabalho de detectar, de relatar, e de segurar erros, mas ajudam-lhe organizar mais eficazmente o trabalho.

Vantagem 2: Propagando erros acima da pilha de chamada

Uma segunda vantagem das exceções é a abilidade de propagar o erro que relata acima da pilha de chamada dos métodos. Suponha que o método readFile é o quarto método em uma série das chamadas aninhadas do método feitas pelo programa principal: method1 chama method2, que chama method3, que se chama finalmente readFile:

method1 {
chamada method2;
}

method2 {
chamada method3;
}

method3 {
chamada readFile;
}

Suponha também que method1 é o único método interessado nos erros que puderam ocorrer dentro da força tradicional method2 e method3 das técnicas da erro-notificação de readFile. para propagar os códigos de erro retornados por ascendente readFile a pilha de chamada até que os códigos de erro alcancem finalmente o método de method1the somente que está interessado nele:

method1 {
erro do errorCodeType;
erro = chamada method2;
se (erro)
doErrorProcessing;
mais
prosiga;
}

errorCodeType method2 {
erro do errorCodeType;
erro = chamada method3;
se (erro)
erro do retorno;
mais
prosiga;
}

errorCodeType method3 {
erro do errorCodeType;
erro = chamada readFile;
se (erro)
erro do retorno;
mais
prosiga;
}

Recorde que o ambiente runtime de Java procurara para trás através da pilha de chamada para encontrar todos os métodos que estiverem interessados em segurar uma exceção particular. Um método pode duck todas as exceções jogadas dentro dele, desse modo permitindo que um método mais distante acima da pilha de chamada trave-a. Daqui, somente os métodos que se importam com erros têm que preocupar-se sobre detectar erros:

method1 {
tentativa {
chamada method2;
} prendedor (exceção e) {
doErrorProcessing;
}
}

method2 joga a exceção {
chamada method3;
}

method3 joga a exceção {
chamada readFile;
}

Entretanto, enquanto o pseudocode mostra, ducking uma exceção requer algum esforço na parte dos métodos do middleman. Todas as exceções verificadas que puderem ser jogadas dentro de um método devem ser especificadas em sua cláusula dos tHRows.

Vantagem 3: Agrupando e diferenciando tipos de erro

Porque todas as exceções jogadas dentro de um programa são objetos, agrupar ou categorizar das exceções são um resultado natural da hierarquia da classe. Um exemplo de um grupo de classes relacionadas da exceção na plataforma de Java é aqueles definida em java.ioIOException e em seus descendentes. IOException é o mais geral e representa qualquer tipo de erro que puder ocorrer ao executar I/O. Seus descendentes representam uns erros mais específicos. Para o exemplo, FileNotFoundException significa que uma lima não poderia ser ficada situada no disco.

Um método pode escrever os alimentadores específicos que podem segurar uma exceção muito específica. A classe de FileNotFoundException não tem nenhum descendente, assim que o seguinte alimentador pode segurar somente um tipo de exceção:

prendedor (FileNotFoundException e) {
...
}

Um método pode travar uma exceção baseada em seu grupo ou tipo geral especificando alguns dos superclasses da exceção na indicação do prendedor. Para o exemplo, para travar todas as exceções de I/O, não obstante seu tipo específico, um alimentador da exceção especifica um argumento de IOException:

prendedor (IOException e) {
...
}

Este alimentador poderá travar todas as exceções de I/O, including FileNotFoundException, EOFException, e assim por diante. Você pode encontrar detalhes sobre o que ocorreu perguntando o argumento passado ao alimentador da exceção. Para o exemplo, use o seguinte imprimir o traço de pilha:

trave (IOException e) {
e.printStackTrace(); //output vai a System.err.
e.printStackTrace(System.out); //emita o traço ao stdout.
}

Você poderia mesmo ajustar acima um alimentador da exceção que segurasse toda a exceção com o alimentador aqui:

trave (exceção e) {alimentador geral da exceção// A (demasiado)
...
}

A classe da exceção é perto do alto da hierarquia da classe de THRowable. Conseqüentemente, este alimentador travará muitas outras exceções além àquelas que o alimentador é pretendido travar. Você pode querer segurar exceções que esta maneira se todos você quiserem seu programa fazer, para o exemplo, é cópia para fora de uma mensagem de erro para o usuário e retira então.

Em a maioria de situações, entretanto, você quer alimentadores da exceção ser tão específicos como possível. A razão é que a primeira coisa que uma obrigação do alimentador é determina que tipo de exceção ocorreu antes que possa se decidir na mais melhor estratégia da recuperação. De fato, não travando erros específicos, o alimentador deve acomodar toda a possibilidade. Os alimentadores da exceção que são lata demasiado geral fazem o código mais error-prone travando e segurando as exceções que não foram antecipadas pelo programador e para qual o alimentador não foi pretendido.

Como notável, você pode criar grupos das exceções e segurar exceções em uma forma geral, ou você pode usar o tipo de exceção específico diferenciar exceções e segurar exceções em uma forma exata.

Disclaimer: Nosso Web site não é responsável para a informação contida por este artigo. Este artigo em nenhuma maneira reflete as vistas, as opiniões, os pensamentos ou a opinião da equipe de funcionários do diretório dos artigos.

Observação da tradução: O artigo "vantagens das exceções na língua de programação de Java" foi traduzido usando um serviço de tradução automatizado. Nós desculpamo-nos sincerely por todos os erros da tradução que ocorram. Obrigado compreendendo.

Online: 637 users browsing the articles directory