java exceptions exception handling with examples
Questo tutorial video sulle eccezioni Java spiega tutto sulla gestione delle eccezioni in Java. Imparerai a conoscere la gerarchia delle eccezioni, i tipi, i metodi di classe e altro:
Quando stiamo eseguendo programmi Java, il normale comportamento o il normale flusso del programma viene interrotto, a causa di alcuni eventi imprevisti.
Per esempio, apriamo un file per leggere i dati. Quando viene eseguita la chiamata Open file, troviamo il file che stiamo cercando di aprire manca. Ciò comporta l'interruzione del normale flusso del programma.
Questo evento che influenza o interrompe il normale flusso del programma è chiamato ' Eccezione '.
=> Visita qui per esplorare la serie di formazione Java per tutti.
Ecco un video tutorial sulla gestione delle eccezioni Java:
Cosa imparerai:
- Gestione delle eccezioni in Java
- Tipi di eccezioni in Java
- Elenco delle eccezioni in Java
- Conclusione
Gestione delle eccezioni in Java
Quando si verifica un'eccezione nel programma, l'esecuzione del programma viene interrotta. Poiché si tratta di una interruzione improvvisa, il sistema genera un messaggio e lo visualizza. Il messaggio generato dal sistema può essere criptico come alcuni codici o illeggibile.
Quindi l'utente normale dovrebbe capire perché il programma ha interrotto la sua esecuzione all'improvviso, dovrebbe conoscerne il motivo. I messaggi generati dal sistema come risultato di un'eccezione potrebbero non essere utili. In Java, possiamo gestire l'eccezione e fornire all'utente messaggi significativi sul problema.
Questa gestione dell'eccezione, comunemente nota come 'La gestione delle eccezioni' è una delle caratteristiche salienti della programmazione Java.
Motivi per cui si verifica l'eccezione
Possiamo avere vari motivi per cui possono verificarsi eccezioni. Se è un'eccezione relativa all'input, il motivo potrebbe essere che i dati di input non sono corretti o illeggibili.
Se otteniamo un'eccezione per l'I / O di file, è possibile che i file con cui abbiamo a che fare non esistano. In un altro momento, potrebbero esserci errori come problemi di rete, stampante non disponibile o funzionante, ecc.
In un programma, oltre alle eccezioni, otteniamo anche errori. Pertanto, per gestire le eccezioni in modo efficace, dobbiamo essere consapevoli delle differenze tra errore e un'eccezione.
Un errore indica un problema più serio con l'applicazione e l'applicazione non dovrebbe tentare di rilevarlo. Al contrario, l'eccezione è una condizione che qualsiasi applicazione ragionevole cercherà di catturare.
Pertanto un errore nell'applicazione è più grave e le applicazioni andrebbero in crash quando riscontrano un errore. Le eccezioni invece si verificano nel codice e possono essere gestite dal programmatore fornendo azioni correttive.
Che cos'è la gestione delle eccezioni?
La gestione delle eccezioni in Java è un meccanismo che utilizza il quale viene mantenuto il normale flusso dell'applicazione. Per fare questo, utilizziamo un potente meccanismo per gestire errori o eccezioni di runtime in un programma.
Una sequenza di codice utilizzata per gestire l'eccezione è chiamata 'gestore delle eccezioni'. Un gestore di eccezioni interroga il contesto nel punto in cui si è verificata l'eccezione. Ciò significa che legge i valori delle variabili che erano nell'ambito mentre si è verificata l'eccezione e quindi ripristina il programma Java per continuare con il flusso normale.
Vantaggi della gestione delle eccezioni
Il vantaggio principale della gestione delle eccezioni è che mantiene il flusso normale dell'applicazione nonostante il verificarsi di un'eccezione. Quando si verifica un'eccezione, il programma di solito si interrompe bruscamente.
Avere un gestore di eccezioni in un programma non causerà la chiusura improvvisa del programma. Invece, un gestore di eccezioni si assicura che tutte le istruzioni nel programma vengano eseguite normalmente e che il flusso del programma non si interrompa bruscamente.
Gerarchia delle eccezioni in Java
Il diagramma seguente mostra la gerarchia delle eccezioni in Java. La classe java.lang.Throwable (discendente della classe Object) è la classe radice di Java Exception. Le classi Exception ed Error derivano da questa classe.
La classe di eccezione è la classe di base per tutte le altre eccezioni.
Di seguito è riportata una gerarchia della classe Exception in Java che elencherà tutte le principali eccezioni di cui un programmatore Java dovrebbe essere a conoscenza.
Classe di eccezione in Java
Come si vede nel diagramma gerarchico, la classe Throwable ha due sottoclassi dirette, ovvero Eccezione ed Errore. Le eccezioni derivanti da un'origine esterna sono descritte nella classe Exception.
La classe Exception dichiara i costruttori come la stessa classe Throwable e il richiamo di ogni costruttore richiama anche la sua controparte Throwable. La classe Exception non dichiara i propri metodi, eredita i metodi della classe Throwable.
Di seguito sono presentati i costruttori e i metodi utilizzati dalla classe Exception.
Costruttori
Costruttore Descrizione eccezione pubblica () Un costruttore predefinito che costruisce una nuova eccezione con il messaggio come null. eccezione pubblica (messaggio String) Costruttore per costruire una nuova eccezione con il messaggio fornito. In questo caso, la causa non viene inizializzata e una chiamata successiva a Throwable.initCause (java.lang.Throwable) può essere utilizzata per inizializzare la causa. eccezione pubblica (messaggio stringa, causa Throwable) Costruisce una nuova eccezione utilizzando un messaggio e una causa dati. eccezione pubblica (causa lanciabile) Costruisce una nuova eccezione con la causa data e un messaggio dato da (cause == null? Null: cause.toString ()) (che in genere contiene la classe e il messaggio di dettaglio della causa). eccezione protetta (messaggio stringa, causa Throwable, boolean enableSuppression, boolean writableStackTrace) Costruisce una nuova eccezione con il messaggio, la causa, l'eliminazione (abilitata o disabilitata) e l'analisi dello stack scrivibile (abilitata o disabilitata) specificati.
Metodi
Metodo Prototipo | Descrizione |
---|---|
public String getMessage () | Ricevi un messaggio dettagliato sull'eccezione che si è verificata. |
getCause lanciabili public () | Ottieni la causa dell'eccezione rappresentata da un oggetto lanciabile |
public String toString () | Concatena il nome della classe con il risultato di getMessage () e restituisce la stringa risultante. |
public void printStackTrace () | Stampa il risultato di toString () e il contenuto della traccia dello stack nel flusso di output dell'errore, System.err. |
public StackTraceElement () getStackTrace () | Ottieni ogni elemento nella traccia dello stack sotto forma di un array. |
public Throwable fillInStackTrace () | Riempi la traccia dello stack con la traccia dello stack corrente. |
Esempio di eccezione
Successivamente, presentiamo un programma Java per dimostrare un esempio di eccezione di base. Qui forniamo una variabile stringa inizializzata con un valore nullo. Quando proviamo a stampare questa variabile, viene generata un'eccezione poiché il valore String non può essere nullo.
class Main { public static void main(String args()){ //declare a String variable and initialize it to null String myStr = null; //print the string System.out.println(myStr.length()); } }
Produzione
Tipi di eccezioni in Java
Java supporta tre tipi di eccezioni:
- Eccezione selezionata
- Eccezione deselezionata
- Errore
In questa sezione, discuteremo tutti i tre tipi precedenti.
# 1) Eccezione selezionata
Alcune eccezioni vengono verificate in fase di compilazione quando il codice viene compilato. Queste sono 'eccezioni verificate'. Il programma Java genera un errore di compilazione quando rileva che il codice all'interno di un programma è soggetto a errori.
Possiamo prenderci cura degli errori di compilazione generati da un'eccezione controllata gestendo le eccezioni racchiudendo il codice in un blocco try-catch o utilizzando la parola chiave throws.
Nella gerarchia delle eccezioni, la classe che eredita direttamente la classe Throwable come IOException, ClassNotFoundException, ecc. Sono tutte eccezioni controllate ad eccezione delle classi RuntimeException ed Error. Queste sono eccezioni non controllate.
Il seguente programma Java mostra le eccezioni verificate, FileNotFoundException e IOException. In questo programma, proviamo ad aprire un file inesistente e leggere da esso.
Poiché il file non esiste, il metodo del file aperto genera FileNotFoundException. Successivamente, quando proviamo a leggere il contenuto del file e chiudere il file, le chiamate dei metodi generano IOException.
import java.io.*; class Main { public static void main(String args()) { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }
Produzione
come faccio ad aprire i file apk
Nell'output precedente, poiché il gestore delle eccezioni è assente, otteniamo errori di compilazione per le eccezioni controllate.
Ora forniamo una clausola throws per questo programma. Poiché il genitore di FileNotFoundException è IOException, specificheremo semplicemente IOException dopo la clausola throws.
import java.io.*; class Main { public static void main(String args()) throws IOException { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }
Produzione
Come si vede dall'output, quando gestiamo l'eccezione, fornisce un output più significativo invece degli errori di compilazione.
# 2) Eccezione non selezionata
Le eccezioni non selezionate sono le eccezioni che vengono controllate in fase di esecuzione. Quindi, nonostante le eccezioni, una raccolta di programmi avrà successo. La maggior parte delle eccezioni non controllate vengono generate a causa dei dati errati utilizzati nel programma.
Le classi che ereditano 'RuntimeException' sono eccezioni non controllate. Eccezioni come ArrayIndexOutofBounds Exception, ArithmeticException, NullPOinterException e così via sono esempi di eccezioni non controllate.
Il seguente programma mostra un'eccezione runtime non controllata causata dalla divisione di un numero per zero.
class Main { public static void main(String args()) { int num1=10; int num2=0; //divide both numbers and print the result int result=num1/num2; System.out.println(result); } }
Produzione
Vediamo che il programma viene compilato con successo e quindi viene lanciata ArithmeticException in fase di esecuzione.
Esempi di eccezione non selezionata:
- Indice della Matrice Fuori Dai Limiti d'Eccezione
- NullPointerException
- IllegalArgumentException
- NumberFormatException
Oltre alle due eccezioni precedenti, ci sono poche altre eccezioni verificate, tra cui:
- SQLException
- InvocationTargetExecption
# 3) Errore
L'errore è solitamente una situazione irreversibile e irreversibile in un programma e quando si verifica un errore, i programmi si bloccano. Alcuni degli esempi di errori in un programma sono OutOfMemoryError, AssertionError e VirtualMachineError, ecc.
La classe Error eredita dalla classe Throwable. L'errore descrive una situazione che non può essere gestita e provoca un arresto anomalo del programma.
Parliamo dell'errore OutOfMemory in questa sezione come esempio di errore.
Sappiamo che tutti gli oggetti in Java vengono allocati utilizzando il nuovo operatore e vengono archiviati nell'heap. Quando l'heap esaurisce la memoria, la Java Virtual Machine (JVM) non può allocare l'oggetto. Allo stesso tempo, il garbage collector non può liberare memoria. Questa situazione dà origine all'errore OutOfMemory.
OutOfMemoryError in Java apparirà come mostrato di seguito:
'exception in thread 'main' java.lang.outofmemoryerror: java heap space'
La presenza di OutOfMemoryError in un programma significa che vengono elaborati troppi dati o che gli oggetti vengono trattenuti per troppo tempo. A volte, può anche essere una libreria di terze parti che utilizza la memoria.
Cause degli errori OutOfMemoryError
# 1) Java Heap Space
Se un'applicazione ha troppi finalizzatori, gli oggetti classe con il metodo Finalize non vengono recuperati immediatamente dal Garbage Collector ma vengono messi in coda per la finalizzazione in un secondo momento. A volte, la finalizzazione non riesce a tenere il passo con il tempo e la memoria dell'heap viene riempita con conseguente OutOfMemoryError.
Un altro motivo per OutOfMemoryError è che la dimensione dell'heap specificata potrebbe essere insufficiente per l'applicazione.
Il codice seguente illustra OutOfMemoryError che può verificarsi a causa di un'enorme dimensione dei dati dichiarata per una matrice.
import java.util.*; public class Main { static List list = new ArrayList(); public static void main(String args()) throws Exception { Integer() array = new Integer(100000 * 100000); } }
Produzione
# 2) Spazio Permgen
Anche l'area di generazione permanente in memoria può essere esaurita e potrebbe generare un errore OutOfMemory.
La dimensione della regione PermGen viene impostata durante l'avvio della JVM. Se l'utente non imposta la dimensione, viene utilizzata la dimensione predefinita specifica della piattaforma.
Sebbene le due precedenti siano solitamente le cause principali del verificarsi di OutOfMemoryError, potrebbero esserci altre cause come la dimensione dell'array che supera il limite della VM, ecc.
Elenco delle eccezioni in Java
Di seguito è riportato un elenco delle principali eccezioni che si verificano in Java. Abbiamo fornito esempi di programmazione per alcune di queste eccezioni. Notare che queste sono eccezioni integrate supportate da Java.
# 1) Eccezione aritmetica: Anomalie aritmetiche come la divisione per zero producono ArithmeticException.
Il programma seguente mostra l'occorrenza di ArithmeticException.
class Main { public static void main(String args()) { try { //define two numbers int num1 = 100, num2 = 0; int result = num1 / num2; // divide by zero //print the result System.out.println('Result = ' + result); } catch (ArithmeticException e) { System.out.println('ArithmeticException:Division by Zero'); } } }
Produzione
# 2) ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException viene generata quando si accede a un elemento di matrice utilizzando un indice non valido. L'indice utilizzato è oltre la dimensione dell'array o è negativo.
# 3) ClassNotFoundException: Se la definizione della classe non viene trovata, viene generata l'eccezione ClassNotFoundException.
# 4) FileNotFoundException: FileNotFoundException viene fornita quando il file non esiste o non si apre.
# 5) IOException: IOException viene generata quando l'operazione di input-output non riesce o viene interrotta.
# 6) Eccezione interrotta: Ogni volta che un thread sta eseguendo l'elaborazione, dormendo o aspettando, viene interrotto lanciando InterruptException.
# 7) NoSuchFieldException: Se una classe non contiene un campo o una variabile specificati, genera NoSuchFieldException.
# 8) NoSuchMethodException: Quando il metodo a cui si accede non viene trovato, viene generata NoSuchMethodException.
# 9) NullPointerException: NullPointerException viene generata quando si fa riferimento a un oggetto null. Questa è l'eccezione più importante e più comune in Java.
# 10) NumberFormatException: Questa eccezione viene sollevata quando un metodo non è in grado di convertire una stringa in un formato numerico.
# 11) RuntimeException: Qualsiasi eccezione che si verifica in fase di esecuzione è una RuntimeException.
# 12) StringIndexOutOfBoundsException: StringIndexOutOfBoundsException viene generata dalla classe String e indica che l'indice è oltre la dimensione dell'oggetto String o è negativo.
# 13) Eccezione EOF: EOFException fa parte del pacchetto java.io e viene lanciata quando viene raggiunta la fine del file e il file viene letto.
# 14) IllegalArgumentException: IllegalArgumentException viene generata quando al metodo vengono passati argomenti illegali o non validi. Per esempio, formato dati errato, valore null quando è richiesto un valore diverso da null o argomenti fuori intervallo.
Il seguente programma Java dimostra l'eccezione IllegalArgumentException.
public class Main { int m; public static void setMarks(int marks) public static void main(String() args) { setMarks(45); setMarks(101); } }
Produzione
Nel programma precedente, IllegalArgumentException viene lanciata nella seconda chiamata alla funzione setMarks in cui si inseriscono i segni che sono fuori intervallo (> 45).
# 15) InputMismatchException: InputMismatchException viene generata quando l'input letto non corrisponde a un modello specificato. Per esempio, se il programma si aspetta un numero intero e legge un float, viene sollevata InputMismatchException.
# 16) NoSuchElementException: NoSuchElementException viene generata quando l'elemento successivo a cui si accede non esiste.
Per esempio, in Enumeration, il metodo nextElement () viene utilizzato per accedere all'elemento successivo dell'enumerazione. Se l'elemento non esiste, viene generata NoSuchElementException. La maggior parte delle raccolte Java genera questa eccezione.
Il programma fornito di seguito lo dimostra.
import java.util.*; public class Main { public static void main(String() args) { Set hash_Set = new HashSet(); //create an empty hashSet. //This throws NoSuchElementException since hashSet is empty hash_Set.iterator().next(); } }
Produzione
scarica mongodb per windows 10 64 bit
# 17) ConcurrentModificationException: ConcurrentModificationException viene solitamente generata dalle classi Collection. Questa eccezione viene generata quando gli oggetti tentano di modificare una risorsa contemporaneamente.
Per esempio, un thread non può modificare una raccolta quando un altro thread vi accede. Se consentiamo due thread, questi due accederanno contemporaneamente alla raccolta e ci saranno incongruenze.
L'esempio seguente mostra ConcurrentModificationException.
import java.awt.List; import java.util.*; public class Main { public static void main(String() args) { ArrayList A_list = new ArrayList<>(); //add elements to the ArrayList A_list.add(10); A_list.add(20); A_list.add(30); Iterator it = A_list.iterator(); while (it.hasNext()) { Integer value = it.next(); System.out.println('ArrayList Value:' + value); if (value.equals(30)) A_list.remove(value); } } }
Produzione
Nel programma precedente, durante la stampa di ArrayList, proviamo a eliminare un elemento allo stesso tempo. Questo è l'accesso simultaneo e quindi viene generata un'eccezione.
Eccezioni personalizzate in Java
Finora abbiamo discusso di tutte le eccezioni integrate o fornite dal linguaggio Java. Oltre a queste eccezioni, possiamo anche definire le nostre eccezioni. Queste sono chiamate eccezioni personalizzate o eccezioni definite dall'utente.
Utilizzando eccezioni personalizzate, possiamo definire le nostre eccezioni secondo le nostre esigenze.
L'esempio seguente mostra l'eccezione personalizzata che abbiamo definito per un valore Integer.
//custom exception definition class InvalidValueException extends Exception{ InvalidValueException(String s){ super(s); } } class Main{ static void validate(int int_val)throws InvalidValueException{ if(int_val<10) //value is valid if> 10 else throw exception throw new InvalidValueException('Invalid value'); else System.out.println('This is valid integer'); } public static void main(String args()){ try{ validate(9); }catch(Exception m){System.out.println('Exception occured: '+m);} System.out.println('Code after Exception'); } }
Produzione
download VPN Europa
Domande frequenti
Q # 1) Cosa intendi per eccezione?
Risposta: Un evento che si verifica durante l'esecuzione di un programma e interrompe il normale flusso di esecuzione del programma è chiamato Eccezione. L'eccezione è indesiderata e imprevista e può verificarsi a causa di fattori esterni o errori di programmazione.
D # 2) Qual è la differenza tra Errore ed Eccezione?
Risposta: Le eccezioni sono eventi che interrompono il normale flusso del programma. Possiamo gestire le eccezioni nel nostro programma e continuare con il programma normalmente. Un errore è un evento irrecuperabile che non può essere gestito e termina il programma.
D # 3) Cosa si intende per gestione delle eccezioni?
Risposta: Il processo di specificare la sequenza di passaggi in un programma per gestire l'eccezione è chiamato gestione delle eccezioni. Fornendo gestori di eccezioni in un programma, possiamo garantire il normale flusso del programma.
D # 4) Quali sono i vantaggi della gestione delle eccezioni in Java?
Risposta: Utilizzando la gestione delle eccezioni possiamo mantenere il normale flusso di esecuzione di un'applicazione. Possiamo anche propagare gli errori nello stack di chiamate quando forniamo gestori di eccezioni.
Q # 5) A cosa serve la gestione delle eccezioni?
Risposta: Non terminare il normale flusso di esecuzione di un'applicazione è l'uso principale dell'avere gestori di eccezioni in un programma. Senza gestori di eccezioni, il programma terminerà e il normale flusso di esecuzione verrà interrotto quando si verifica un'eccezione.
Con l'eccezione gestita correttamente nel programma, può continuare con la sua normale esecuzione anche quando si verifica un'eccezione.
Altri esempi sulle eccezioni
Un'eccezione è un evento che si verifica mentre il programma è in esecuzione e interrompe l'esecuzione del programma. Per questo motivo il prodotto software terminerà bruscamente.
Quando si verifica questa eccezione, Java crea un oggetto con un messaggio di errore e informazioni sulla classe. Questo è l'oggetto eccezione.
Perché abbiamo bisogno di un'eccezione in Java?
Classe ExcepDemo senza eccezioni:
public class ExcepDemo { public static void main(String() args) { int i=5; int j=0; System.out.println(i/j); System.out.println('statement after division'); } }
PRODUZIONE:
Classe ExcepDemo con gestione delle eccezioni:
public class ExcepDemo { public static void main(String() args) { // TODO Auto-generated method stub int i=5; int j=0; try { System.out.println(i/j); } catch(ArithmeticException ae) { System.out.println('wrong input'); } System.out.println('statement after division'); } }
PRODUZIONE:
Prova, cattura e infine blocca:
- Un'eccezione viene gestita da try, catch block.
- Le dichiarazioni che possono portare a eccezioni sono scritte all'interno del blocco try.
- Quando si verifica un'eccezione, verranno eseguite le istruzioni all'interno del blocco catch. Se non si verifica un'eccezione, il blocco catch non verrà eseguito.
- Indipendentemente dall'eccezione avvenuta o meno, verrà eseguito il blocco finale.
Tipi di eccezione
Eccezione non selezionata:
Poiché le eccezioni deselezionate possono essere evitate con la corretta programmazione ( Per esempio. puntatore nullo Eccezione, Eccezione aritmetica) non verrà controllata dal compilatore. L'eccezione deselezionata verrà generata in fase di esecuzione.
Eccezione selezionata:
- L'eccezione selezionata verrà controllata dal compilatore ed è obbligatorio lanciare o gestire l'eccezione.
- Questa eccezione viene utilizzata per separare il codice di gestione degli errori dal codice normale.
- Tutte le eccezioni controllate sono raggruppate ed è utile per differenziare i problemi.
Esempio: java.io
import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class DemoExpChecked { public static void main(String() args) { try { File file=new File('input.txt'); BufferedReader br = new BufferedReader(new FileReader(file)) ; String content; while ((content=br.readLine())!=null) { System.out.println(content); } br.close(); } catch(IOException e) { e.printStackTrace(); } } }
Errori
Può verificarsi un errore a causa di errori logici del programma o di qualsiasi memoria relativa al problema JVM.
Esempio: Errore di memoria esaurita o errore di overflow dello stack.
Lancio e lancio
La parola chiave 'Throw' viene utilizzata per generare l'eccezione, mentre la parola chiave 'throws' viene utilizzata per dichiarare l'eccezione.
Lancia un programma di esempio:
public class Demothrow { String content ; public void driving(String c) { this.content=c; if (content.isEmpty()) { throw new NullPointerException('content is empty'); } else { System.out.println('content=='+content); } } public static void main(String() args) { Demothrow dt=new Demothrow(); dt.driving(''); } }
Lancia il programma di esempio:
I lanci vengono utilizzati per fornire informazioni che questo metodo genera questa particolare eccezione. Quando chiami quel particolare metodo, devi gestire quell'eccezione.
public class DemoThrows { int i=2,j=0; public void checkmethod () throws ArithmeticException{ System.out.println(i/j); } public static void main(String() args) { DemoThrows d =new DemoThrows(); try { d.checkmethod(); } catch (ArithmeticException ae) { ae.printStackTrace(); } } }
Punti chiave da notare:
- Le eccezioni sono eventi anormali che si verificano durante l'esecuzione del programma e influenzeranno il flusso di esecuzione.
- Un errore è diverso dalle eccezioni. Esempio di errori: Memoria esaurita.
- Le eccezioni selezionate vengono controllate durante la compilazione ed è obbligatorio trattare questa eccezione selezionata.
- Si verifica un'eccezione non controllata durante il runtime.
Conclusione
Questo tutorial sulla gestione delle eccezioni in Java ha introdotto la definizione di eccezioni, la gestione delle eccezioni e la gerarchia delle eccezioni in Java. Abbiamo anche discusso la classe delle eccezioni in Java che fornisce vari costruttori e metodi per accedere alle eccezioni.
Abbiamo esplorato un elenco delle eccezioni comuni che si verificano in Java e abbiamo visto gli esempi di programmazione per l'eccezione principale. Abbiamo anche discusso i principali errori che si verificano in un programma Java insieme ai tipi di eccezioni ed eccezioni personalizzate.
=> Controlla TUTTI i tutorial Java qui.
Lettura consigliata
- Le 10 migliori eccezioni al selenio e come gestirle (codice esatto)
- Gestione delle eccezioni JDBC - Come gestire le eccezioni SQL
- Come gestire le eccezioni negli script Groovy SoapUI - Tutorial SoapUI # 11
- Java String con String Buffer e String Builder Tutorial
- Distribuzione Java: creazione ed esecuzione di file JAR Java
- Thread Java con metodi e ciclo di vita
- Java Virtual Machine: come JVM aiuta nell'esecuzione di applicazioni Java
- Modificatori di accesso in Java - Tutorial con esempi