Qual è la differenza tra lancio vs. lancia in Java

Pubblicato: 2013-07-23

Qual è la differenza tra lancio vs. lancia in Java

Uno lo dichiara e l'altro lo fa

Ci sono cinque parole chiave relative alla gestione delle eccezioni in Java, ad esempio try, catch, finalmente, throw e throws . A parte la differenza tra final, finalize e finalize , throw vs throws è una delle domande frequenti dell'intervista Java.

  • La parola chiave throw viene utilizzata per lanciare Exception da qualsiasi metodo o blocco statico in Java mentre la parola chiave throws , utilizzata nella dichiarazione del metodo, indica quale Exception può essere generata da questo metodo. Non sono intercambiabili.
  • Se un metodo genera un'eccezione verificata come mostrato nell'esempio seguente, il chiamante può gestire questa eccezione catturandola o rilanciarla dichiarando un'altra clausola throws nella dichiarazione del metodo.
  • La clausola Throw può essere utilizzata in qualsiasi parte del codice in cui si ritiene che debba essere generata un'eccezione specifica al metodo chiamante.

Comprendere le eccezioni 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

Se un metodo sta generando un'eccezione, dovrebbe essere circondato da un blocco try catch per catturarlo o quel metodo dovrebbe avere la clausola throws nella sua firma. Senza la clausola throws nella firma, il compilatore JVM Java non sa cosa fare con l'eccezione. La clausola throws dice al compilatore che questa particolare eccezione verrebbe gestita dal metodo chiamante.

Di seguito è riportato un esempio molto semplice che spiega il comportamento di Throw, Throws, Try, Catch, Infine block in 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 ;
}
 
}

Risultato:

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 )

Eccezione puntatore nullo - Crunchify

Ora sostituisci semplicemente la riga 45 e 46 con la riga sottostante per vedere il risultato seguente:

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

Nuovo risultato:

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

Elenco di tutti i tutorial Java che potrebbero interessarti.

Suggerimenti bonus sulle eccezioni:

  • L'esecuzione normale del programma viene immediatamente ramificata quando viene generata un'eccezione.
  • Le eccezioni controllate devono essere catturate o inoltrate. Questo può essere fatto in un'istruzione try... catch o definendo l'eccezione nella definizione del metodo.
  • L'eccezione viene rilevata dal primo blocco catch la cui classe di eccezione associata corrisponde alla classe o a una superclasse dell'eccezione generata.
  • Se non viene trovato alcun blocco catch corrispondente nella catena di eccezioni, il thread contenente l'eccezione generata viene terminato.
  • Il blocco finally dopo un'istruzione try... catch viene eseguita indipendentemente dal fatto che un'eccezione venga rilevata o meno.
  • Il ritorno all'interno di un blocco finally interrompe la catena di eccezioni all'invocatore anche per eccezioni non rilevate.