Care este diferența dintre aruncare vs. aruncă în Java

Publicat: 2013-07-23

Care este diferența dintre aruncare vs. aruncă în Java

Unul o declară, iar celălalt o face

Există cinci cuvinte cheie legate de gestionarea excepțiilor în Java, de exemplu try, catch, finally, throw and throws . În afară de diferența dintre final, finally și finalize , throw vs throws este una dintre întrebările frecvente pentru interviul Java.

  • cuvântul cheie throw este folosit pentru a arunca excepție de la orice metodă sau bloc static în Java, în timp ce cuvântul cheie throw , folosit în declarația metodei, indică excepția care poate fi aruncată prin această metodă. Nu sunt interschimbabile.
  • Dacă orice metodă aruncă o excepție bifată, așa cum se arată în exemplul de mai jos, atunci apelantul poate fie gestiona această excepție prin capturarea ei, fie o poate arunca din nou declarând o altă clauză throws în declarația metodei.
  • Clauza Throw poate fi folosită în orice parte a codului în care simțiți că trebuie aruncată o anumită excepție la metoda de apelare.

Subestimarea excepțiilor 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

Dacă o metodă aruncă o excepție, ar trebui fie înconjurată de un bloc try catch pentru a o prinde, fie acea metodă ar trebui să aibă clauza throws în semnătură. Fără clauza throws din semnătură, compilatorul Java JVM nu știe ce să facă cu excepția. Clauza throws spune compilatorului că această excepție specială va fi gestionată de metoda de apelare.

Mai jos este un exemplu foarte simplu care explică comportamentul Throw, Throws, Try, Catch, Finally block în 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 ;
}
 
}

Rezultat:

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 )

Null Pointer Exception - Crunchify

Acum înlocuiți linia 45 și 46 cu linia de mai jos pentru a vedea rezultatul de mai jos:

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

Rezultat nou:

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 tuturor tutorialelor Java care v-ar putea interesa.

Sfaturi bonus pentru excepții:

  • Execuția normală a programului este imediat ramificată atunci când este aruncată o excepție.
  • Excepțiile verificate trebuie să fie capturate sau transmise. Acest lucru se poate face într-o instrucțiune try... catch sau prin definirea excepției în definiția metodei.
  • Excepția este capturată de primul bloc catch a cărui clasă de excepție asociată se potrivește cu clasa sau cu o superclasă a excepției aruncate.
  • Dacă nu se găsește niciun bloc catch care se potrivește în lanțul de excepții, firul de execuție care conține excepția aruncată este încheiat.
  • Blocul final după o instrucțiune try... catch este executat indiferent dacă o excepție este capturată sau nu.
  • Revenirea într-un bloc final întrerupe lanțul de excepții la invocator chiar și pentru excepții neprinse.