Differenza tra lancio e lancio in Java
Contenuto
Lancio e lancio sono le parole chiave utilizzate nella gestione delle eccezioni. Il gettare la parola chiave viene utilizzata per trasferire manualmente l'istanza dell'eccezione creata dal programmatore alla JVM. Il getta parola chiave utilizzata per trasferire la responsabilità della gestione dell'eccezione verificata nel metodo nel metodo chiamante. La differenza fondamentale tra lancio e lancio è che la parola chiave lancio usa l'oggetto eccezione mentre la parola chiave usa il nome delle classi di eccezione.
- Tabella di comparazione
- Definizione
- Differenze chiave
- Conclusione
Tabella di comparazione
| Base di confronto | gettare | getta |
|---|---|---|
| Di base | La parola chiave throw consegna manualmente il nostro oggetto eccezione creato a JVM. | La parola chiave generata viene utilizzata per delegare la responsabilità della gestione delle eccezioni al chiamante del metodo. |
| Sintassi | lanciare istanza gettabile; | return_type method_name (elenco parametri) genera ExceptionClass_list { // corpo del metodo } |
| Seguito da | La parola chiave throw è seguita da un oggetto eccezione. | La parola chiave genera è seguita dall'elenco delle classi di eccezioni che possono verificarsi nel metodo. |
| Numero di eccezione generata | La parola chiave throw può generare un'unica istanza di eccezione. | La parola chiave generata può dichiarare più classi di eccezioni separate da una virgola. |
Definizione di tiro
La parola chiave "gettare"Viene utilizzato per consegnare manualmente la nostra istanza di eccezione creata alla JVM (Java Virtual Machine). Se "lancio" non viene utilizzato per generare un'istanza di eccezione e si verifica l'eccezione, il sistema di runtime lancia internamente l'istanza di eccezione a JVM e il programma termina in modo anomalo. La forma generale della parola chiave lancio è:
lanciare Throwable_instance;
Above the Throwable_instance deve essere un oggetto della classe Throwable. I tipi primitivi come int, float o char e l'istanza di classe non gettabile non possono essere lanciati usando la parola chiave throw.
Facciamo un esempio per comprendere il lancio della parola chiave.
Test di classe {Vuoto statico pubblico principale (String args) {throw new ArithmeticException ("/ by zero"); }}
Nel codice sopra, la parola chiave throw genera un'istanza della classe Exception "ArithmeticException". Se la parola chiave throw non fosse stata utilizzata, il metodo main () avrebbe creato internamente un oggetto eccezione trasferito alla JVM.
I punti da ricordare sulla parola chiave lanciare:
- Passa manualmente l'oggetto eccezione alla JVM.
- È utilizzato al meglio per le eccezioni definite dall'utente o per le eccezioni personalizzate.
- Se la memoria non è allocata all'oggetto eccezione generato dalla parola chiave throw, si verifica un'eccezione di runtime, NullPointerException.
- La parola chiave throw interrompe l'esecuzione del programma immediatamente dopo il suo verificarsi. non possiamo scrivere direttamente alcuna dichiarazione dopo la dichiarazione di lancio. Se scriviamo qualsiasi stato direttamente dopo la dichiarazione di lancio, il compilatore mostrerà una dichiarazione di errore, non raggiungibile durante la compilazione.
- Solo gli oggetti della classe Throwable possono essere lanciati usando la parola chiave throw. Se l'oggetto generato non è un oggetto della classe Gettabile, viene visualizzato un errore in fase di compilazione “È stato trovato un tipo incompatibile. . richiesto java.lang.Throwable ”
Nota:
La parola chiave throw viene utilizzata in C ++, JAVA, C #, per generare manualmente un'eccezione.
Definizione di tiri
Il "getta"Parola chiave viene utilizzata per delegare la responsabilità della gestione dell'eccezione verificata nel metodo al relativo metodo chiamante. Il metodo chiamante è responsabile della gestione dell'eccezione che può essere qualsiasi altro metodo o JVM. Dichiara l'elenco delle classi di eccezioni che possono verificarsi nel metodo.
L'uso della parola chiave tiri convince il compilatore che l'eccezione verificata nel metodo deve essere gestita dal metodo chiamante, pertanto non si verifica alcun errore di compilazione. Tuttavia, il metodo chiamante deve gestire l'eccezione o delegare la responsabilità di gestire l'eccezione al suo metodo gerarchico. Quando si verifica l'eccezione di runtime, quindi anche dopo l'uso della parola chiave throw, non impedisce la chiusura anomala del programma. Se il metodo chiamante è main (), per impostazione predefinita la JVM gestisce l'eccezione.
La forma generale della parola chiave getta è:
return_type method_name (lista parametri) genera exceptionClass_list {// body of method}
Possiamo vedere che la parola chiave genera appare dopo la firma del metodo e può contenere l'elenco delle classi di eccezioni che possono verificarsi nel metodo. L'elenco delle classi di eccezioni scritte dopo il lancio della parola chiave è separato dalla virgola.
Facciamo un esempio per comprendere la parola chiave plaid.
calss Test {public static void main (String args) genera InterruptedException {thread sleep (10000); }}
Nel codice sopra, il thread principale viene messo in modalità sleep per qualche tempo usando il metodo sleep (). Ora, quando il metodo principale è inattivo, è possibile che gli altri thread possano interrompere il thread principale. Ma, dopo la firma del metodo main (), viene utilizzata la parola chiave throw, quindi il programma si compila facilmente. La parola chiave generata indica la classe di eccezione verificata InterruptedException. Ora, se qualsiasi altro thread interrompe il thread principale durante il runtime, la parola chiave getta porterebbe tale eccezione al chiamante del metodo main (), ovvero JVM. La JVM terminerebbe il programma in modo anomalo.
I punti da ricordare su lancia la parola chiave:
- La parola chiave plaid viene utilizzata solo per dichiarare le classi di eccezioni selezionate. L'uso della parola chiave genera per un'eccezione non selezionata non ha alcun impatto.
- Se il metodo non desidera gestire l'eccezione da solo, delega tale eccezione al metodo chiamante di quella classe utilizzando la parola chiave throws.
- Il suo utilizzo consente solo la compilazione regolare del programma.
- Se si verifica un'eccezione in fase di esecuzione, il programma termina in modo anomalo, anche dopo l'uso della parola chiave plaid.
- Si consiglia di utilizzare il blocco try / catch per la normale chiusura del programma se si verifica un'eccezione in fase di esecuzione.
Nota:
La parola chiave genera solo in Java. C ++ e C # non usano la parola chiave throws.
- La parola chiave lancio, consegna la responsabilità della gestione delle eccezioni a JVM manualmente mentre, la parola chiave genera, consegna la responsabilità della gestione delle eccezioni al metodo chiamante del codice in cui si è verificata un'eccezione.
- La parola chiave throw è seguita dall'oggetto eccezione che passa alla JVM. D'altra parte, genera la parola chiave è seguita dalle classi di eccezione che possono verificarsi nel metodo.
- La parola chiave throw può generare un singolo oggetto eccezione alla volta, mentre la parola chiave throw può dichiarare più classi di eccezioni separate da una virgola alla volta.
Conclusione:
La parola chiave di lancio è utilizzata al meglio per l'eccezione personalizzata. Il blocco try / catch è il migliore per gestire le eccezioni rispetto alla parola chiave generata.
