¿Cuál es la diferencia entre tirar vs. lanza en Java

Publicado: 2013-07-23

¿Cuál es la diferencia entre tirar vs. lanza en Java

Uno lo declara y el otro lo hace.

Hay cinco palabras clave relacionadas con el manejo de excepciones en Java, por ejemplo , probar, atrapar, finalmente, lanzar y lanzar . Además de la diferencia entre final, finalmente y finalizar , throw vs throws es una de las preguntas más frecuentes en las entrevistas de Java.

  • La palabra clave throw se usa para lanzar una excepción desde cualquier método o bloque estático en Java, mientras que la palabra clave throws , utilizada en la declaración del método, indica qué excepción puede ser lanzada por este método. No son intercambiables.
  • Si algún método arroja una excepción marcada como se muestra en el ejemplo a continuación, la persona que llama puede manejar esta excepción captándola o puede volver a lanzarla declarando otra cláusula throws en la declaración del método.
  • La cláusula Throw se puede usar en cualquier parte del código en la que sienta que se debe lanzar una excepción específica al método de llamada.

Subestimando las excepciones de Java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
java . lang . Object
   |
   +-- java . lang . Throwable
         |
         +-- java . lang . Exception
         |      |
         |      +-- java . lang . ClassNotFoundException
         |      |
         |      +-- java . io . IOException
         |      |      |
         |      |      +-- java . io . FileNotFoundException
         |      |
         |      +-- java . lang . RuntimeException
         |            |
         |            +-- java . lang . NullPointerException
         |            |
         |            +-- java . lang . IndexOutOfBoundsException
         |                  |
         |                  +-- java . lang . ArrayIndexOutOfBoundsException
         |
         +-- java . lang . Error
               |
               +-- java . lang . VirtualMachineError
                     |
                     +-- java . lang . OutOfMemoryError

Si un método lanza una excepción, debe estar rodeado por un bloque try catch para atraparla o ese método debe tener la cláusula throws en su firma. Sin la cláusula throws en la firma, el compilador Java JVM no sabe qué hacer con la excepción. La cláusula throws le dice al compilador que esta excepción en particular sería manejada por el método de llamada.

A continuación se muestra un ejemplo muy simple que explica el comportamiento de los bloques Throw, Throws, Try, Catch, Finalmente en Java.

CrunchifyThrowThrows.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com . crunchify . tutorials ;
 
import java . io . FileInputStream ;
import java . io . FileNotFoundException ;
 
/**
* @author Crunchify.com
*/
 
public class CrunchifyThrowThrows {
 
@SuppressWarnings ( "unused" )
public static void main ( String args [ ] ) throws Exception {
FileInputStream crunchifyStream1 = null ;
FileInputStream crunchifyStream2 = null ;
String fileName = "Crunchify.txt" ;
 
System . out . println ( "main: Starting " + CrunchifyThrowThrows . class . getName ( ) + " with file name = " + fileName ) ;
 
// get file input stream 1
try {
crunchifyStream1 = crunchifyTest1 ( fileName ) ;
} catch ( FileNotFoundException ex ) {
System . out . println ( "main: Oops, FileNotFoundException caught" ) ;
} catch ( Exception ex ) {
System . out . println ( "main: Oops, genreal exception caught" ) ;
}
 
// get file input stream 2
crunchifyStream2 = crunchifyTest2 ( fileName ) ;
System . out . println ( "main: " + CrunchifyThrowThrows . class . getName ( ) + " ended" ) ;
}
 
public static FileInputStream crunchifyTest1 ( String fileName ) throws FileNotFoundException {
FileInputStream crunchifyStream = new FileInputStream ( fileName ) ;
System . out . println ( "crunchifyTest1: File input stream created" ) ;
return crunchifyStream ;
}
 
public static FileInputStream crunchifyTest2 ( String fileName ) throws Exception {
FileInputStream crunchifyStream = null ;
try {
crunchifyStream = new FileInputStream ( fileName ) ;
} catch ( FileNotFoundException ex ) {
throw new Exception ( "crunchifyTest2: Oops, FileNotFoundException caught" ) ;
//System.out.println("crunchifyTest2: Oops, FileNotFoundException caught");
} finally {
System . out . println ( "crunchifyTest2: finally block" ) ;
}
System . out . println ( "crunchifyTest2: Returning from crunchifyTest2" ) ;
return crunchifyStream ;
}
 
}

Resultado:

Result
1
2
3
4
5
6
main : Starting com . crunchify . tutorials . CrunchifyThrowThrows with file name = Crunchify . txt
main : Oops , FileNotFoundException caught
crunchifyTest2 : finally block
Exception in thread "main" java . lang . Exception : crunchifyTest2 : Oops , FileNotFoundException caught
at com . crunchify . tutorials . CrunchifyThrowThrows . crunchifyTest2 ( CrunchifyThrowThrows . java : 45 )
at com . crunchify . tutorials . CrunchifyThrowThrows . main ( CrunchifyThrowThrows . java : 30 )

Excepción de puntero nulo - Crunchify

Ahora simplemente reemplace las líneas 45 y 46 con la línea de abajo para ver el resultado a continuación:

Replace line 45 and 46 with these one...
1
2
//throw new Exception("crunchifyTest2: Oops, FileNotFoundException caught");
System . out . println ( "crunchifyTest2: Oops, FileNotFoundException caught" ) ;

Nuevo resultado:

Result2
1
2
3
4
5
6
main : Starting com . crunchify . tutorials . CrunchifyThrowThrows with file name = Crunchify . txt
main : Oops , FileNotFoundException caught
crunchifyTest2 : Oops , FileNotFoundException caught
crunchifyTest2 : finally block
crunchifyTest2 : Returning from crunchifyTest2
main : com . crunchify . tutorials . CrunchifyThrowThrows ended

Lista de todos los tutoriales de Java que le pueden interesar.

Consejos adicionales sobre excepciones:

  • La ejecución normal del programa se bifurca inmediatamente cuando se lanza una excepción.
  • Las excepciones marcadas deben capturarse o reenviarse. Esto se puede hacer en una sentencia try... catch o definiendo la excepción en la definición del método.
  • La excepción es capturada por el primer bloque catch cuya clase de excepción asociada coincide con la clase o una superclase de la excepción lanzada.
  • Si no se encuentra ningún bloque catch coincidente en la cadena de excepción, el subproceso que contiene la excepción lanzada finaliza.
  • El bloque finalmente después de una sentencia try... catch se ejecuta independientemente de si se detecta una excepción o no.
  • Regresar dentro de un bloque finalmente rompe la cadena de excepciones al invocador incluso para excepciones no detectadas.