Cómo lanzar la excepción en Java

Una excepción es un error potencial, del cual el sistema Java señala el programa Java. Si la excepción (error) no se maneja, el hilo en cuestión dejará de funcionar. Si el programa fuera un solo hilo, entonces el programa dejaría de funcionar. Considere el siguiente programa: Public Class Theclass
public static void main (string [] args)
Sistema.afuera.println ("visto 1");
int numerator = 6;
int denominator = 0;
int cociente = numerator / denominator;
Sistema.afuera.println ("visto 2");
Sistema.afuera.println (cociente);

Este programa intenta dividir por 0 en la cuarta declaración en el método main (). En matemáticas, no se debe dividir ningún número por 0. Las computadoras tampoco permiten esto. Este programa debe imprimir "visto 1", entonces si la división por cero es posible por la computadora, el programa debe imprimir "visto 2" y luego imprimir el cociente de 6 dividido por cero.

Este programa es compilado con éxito por el compilador Javac. Sin embargo, cuando el programa está ejecutado por la máquina virtual Java (sistema operativo), se imprime "See View 1" y el programa se detiene en la cuarta declaración, donde se espera división por cero, de donde y luego) un mensaje de error es emitido (mostrado). El programa deja de ejecutar en la declaración de división por cero, imprime un mensaje de error y deja de funcionar. Después de eso, las dos últimas declaraciones no se ejecutan (no funcionan).

Sin embargo, si esto fuera multiplicación por cero, lo que está permitido, entonces las dos últimas declaraciones se habrían ejecutado. Este artículo proporciona los conceptos básicos de lanzar y manejar una excepción en Java.

Errores de manejo

Con Java, es posible manejar un error, como la división por cero, con código simple; para que las declaraciones (codificación) después del error funcionen (se ejecutará). ¿Cuál es el error aquí?? - El error aquí es división por cero. El código (solución) por el programador no debe permitir que se realice el error. El programador tiene que codificar lo que se conoce como lanzar el error, que es un nuevo objeto de excepción. El objeto de excepción tiene que ser atrapado. Cuando se atrapa el objeto de excepción, el programa tiene que recuperarse de él. Recuperarse de un error significa manejar la excepción.

La clase de biblioteca de excepción maneja el error más que el programador. La clase de excepción no tiene que importarse al comienzo del programa. Esta importación se realiza automáticamente, sin la ayuda del programador.

La clase de excepción

Hay dos clases principales de manejo de errores en Java: la clase de excepción y la clase de error. Este artículo solo trata con la clase de excepción. Como personaje, la clase de excepción conoce errores ordinarios, como los valores de división por cero y no deseados en una cadena literal.

Cuando se lanza un nuevo objeto de excepción, justo después de la declaración que resultaría en un error, la biblioteca de clase de excepción sabría el error; Si es un error ordinario. La clase de excepción no tiene que importarse al comienzo del programa. Esta importación se realiza automáticamente, sin la ayuda del programador.

La declaración de prueba de Java

La declaración de try es una declaración compuesta, que consiste en el bloque de try y un bloque de captura. En forma simplificada, la sintaxis es:

intentar
//planteamiento del problema;
arrojar una nueva excepción ();
* Declaraciones Si no se produce ningún error *

Catch (excepción e)
Sistema.afuera.println ("Mensaje de excepción:" + E.getMessage ());

Prueba es una palabra reservada; Catch es una palabra reservada. El bloque de try tiene la declaración del problema. Una declaración como,

int cociente = numerator / denominator;

es una declaración del problema. Si el denominador no es cero, no se produce ningún error. Si el denominador es cero, ese es un error. La declaración de lanzamiento típicamente sería,

arrojar una nueva excepción ();

Esta declaración de lanzamiento debe venir inmediatamente después de la declaración del problema. Si se produce un error, la declaración de lanzamiento lanza un nuevo objeto de excepción. Tenga en cuenta los paréntesis. Si el denominador es 0, se lanza un nuevo objeto de excepción. Debajo de la declaración de lanzamiento hay otras declaraciones que se ejecutarían si no se produjera error.

El bloque de captura anterior tiene una declaración. Puede tener más. La declaración de lanzamiento en el bloque de try lanza un objeto de excepción, que está atrapado entre los paréntesis de la firma de bloqueo de captura, para un mayor procesamiento dentro de su bloque. Esta actividad es similar a una llamada de método, con un argumento a ser recibido por los paréntesis de la implementación del método para su posterior procesamiento en el bloque del método.

Recuerde que el objeto de excepción puede reconocer diferentes tipos de errores ordinarios y hacer frente a ellos. El objeto de excepción tiene el método, getMessage (). Este método devuelve un mensaje que el usuario puede entender como la causa del error. Esta llamada de método se emplea dentro del bloque de captura.

El siguiente programa pone en práctica la declaración Try-Compound, con el problema de división por cero anterior:

clase pública THECLASS
public static void main (string [] args)
Sistema.afuera.println ("visto 1");
int numerator = 6; int denominator = 0; int cociente;
intentar
if (denominator == 0)
cociente = numerador / denominador;
arrojar una nueva excepción ();

demás
cociente = numerador / denominador;
Sistema.afuera.println ("visto 2");
Sistema.afuera.println (cociente);

Catch (excepción e)
Sistema.afuera.println ("Mensaje de excepción:" + E.getMessage ());

Sistema.afuera.println ("continúa");

El bloque de try tiene una declaración de IF-compuesto. El IF-Part ejecutaría la declaración del problema cuando el denominador es cero. El otro-parte ejecutaría la declaración del problema cuando no ocurriría ningún error cuando el denominador no sea cero. Esto significa que el programador tiene que guiar el empleo del esquema de manejo de excepciones. Y así, en este caso, la declaración del problema se ha escrito dos veces: una vez en la partida if y una vez en la parte más. INT no precede a la declaración del problema porque el cociente se ha declarado antes de la declaración de compuesto try.

En el bloque de try, la declaración de lanzamiento está justo debajo de la declaración del problema en la parte if de la declaración de compuesto. No está en la parte de la declaración de compuesto. No tiene que estar allí porque la otra parte es para la situación cuando el denominador (operando) no es cero (no tiene ningún problema).

Lea el programa anterior. El numerador es 6. Si el denominador fuera 2, la salida habría sido:

visto 1
visto 2
3
Continúa

Esto significa que se ejecutó la otra parte de la declaración de compuesto IF, no la parte de la declaración IF-compuesta. De hecho, el IF-PART (Código) de la declaración IF-compuesto no se ejecutó porque el denominador no era cero. El resto del código en el bloque de try se ejecutó. Se supone que el resto del código en el bloque de try se ejecuta.

Cuando el denominador es 0, el programa producirá la salida:

visto 1
Mensaje de excepción: / por cero
Continúa

Solo el código en la parte del bloque de try se ha ejecutado en esta situación. Esto significa que la declaración de lanzamiento fue ejecutada. El más-part y el código debajo de la instrucción IF-compuesto no se ha ejecutado. Normalmente no se ejecutan en esta situación.

El bloque de captura no se ejecuta cuando no hay problema. Ahora, el bloque de captura fue ejecutado. Es decir, se ejecutó el código de una sola declaración en el bloque de captura. Se lanza el nuevo objeto de excepción, se recibió como e. El método getMessage () del objeto, e que conoce los errores ordinarios (incluido el error de división por cero) devolvió el mensaje, "/ por cero".

Con este mensaje devuelto, el usuario sabría que ocurrió un error de división por cero y se manejó. El manejo, aquí, significa que la división por cero no causó ningún daño al programa y, aunque el resto del código por debajo del punto de error en la instrucción Try-Compound no se ejecutaría, el código debajo del Try- La declaración compuesta se ejecutaría. Si el esquema de manejo no estuviera presente, el programa habría terminado, y cualquier código a continuación que no hubiera estado en la declaración de compuesto de try no se habría ejecutado.

Excepción de lanzamiento, por un método

En Java, la declaración Showle-Exception puede lanzar una excepción en el bloque de try, como se ilustra arriba. Un método también puede lanzar una excepción, pero con una sintaxis diferente, todavía relacionada con el bloque de try. El núcleo del código de try-block ahora está en el cuerpo del método y no en el bloque de try. El siguiente programa repite el anterior, pero con un método que lanza la excepción. La clase con la implementación del método es:

Clase Aclass
int mthd (int nume, int deno) lanza la excepción
int cuti = nume / deno;
return coti;

El código principal en el método aquí es la declaración del problema. La declaración del problema ya no está en el bloque de try (a continuación). La declaración del problema se ha escrito una vez, aquí y para todo el programa (no se escribe dos veces). La expresión de lanzamiento ahora es diferente. Es,

Lanza la excepción

prolongar la firma del método a la derecha. "Throw" aquí está "lanzamientos", con una S. La excepción, aquí, no tiene paréntesis.

Ahora no hay necesidad de la declaración IF-compuesto en todo el programa. El cuerpo del método y la "excepción de lanza" sirven al propósito de la semántica de la declaración compuesta if-else. La clase principal se convierte en:

clase pública THECLASS
public static void main (string [] args)
Sistema.afuera.println ("visto 1");
int numerator = 6; int denominator = 0; int cociente;
intentar
AclasseObj = new Aclass ();
Cociente = EOBJ.MTHD (numerador, denominador);
Sistema.afuera.println ("visto 2");
Sistema.afuera.println (cociente);

Catch (excepción e)
Sistema.afuera.println ("Mensaje de excepción:" + E.getMessage ());

Sistema.afuera.println ("continúa");

Todavía tiene la declaración de compuesto de try-capch. Sin embargo, la declaración del problema no está aquí y no se escribe dos veces. La declaración de compuesto if-else tampoco está aquí. Ya no se necesita en ningún lugar del programa. La salida con su mensaje de error es el mismo que antes, yo.mi.

visto 1
Mensaje de excepción: / por cero
Continúa

El comportamiento del programa completo es como antes.

La cláusula finalmente

La declaración de try tiene tres cláusulas: la cláusula de prueba, la cláusula de captura y la cláusula finalmente. Puede haber más de una cláusula de captura; ver más tarde. El bloque Finalmente llega al final de la declaración de compuesto de try, y es que el programador transmita un mensaje al usuario que se manejó el posible error. La codificación de la cláusula finalmente es opcional. El siguiente código ilustra un uso de la cláusula finalmente para el programa anterior:

Sistema.afuera.println ("visto 1");
int numerator = 6; int denominator = 0; int cociente;
intentar
AclasseObj = new Aclass ();
Cociente = EOBJ.MTHD (numerador, denominador);
Sistema.afuera.println ("visto 2");
Sistema.afuera.println (cociente);

Catch (excepción e)
Sistema.afuera.println ("Mensaje de excepción:" + E.getMessage ());

finalmente
Sistema.afuera.println ("Cualquier error se manejó.");

Si el denominador es 2, la salida sería:

visto 1
visto 2
3
Se manejó cualquier error.
Continúa

Si el denominador es 0, la salida sería:

visto 1
Mensaje de excepción: / por cero
Se manejó cualquier error.
Continúa

El bloque finalmente se ejecuta, ya sea que ocurriera o no un error.

Conclusión

Se lanza una excepción, con la declaración simple en el bloque de try, posiblemente codificada con una declaración de compuesto IF y la declaración del problema. Una excepción aún puede ser lanzada por un método en relación con la declaración de prueba de prueba. Este artículo ha sido los conceptos básicos de lanzar una excepción en Java.