Grafico comparativo
| Base di confronto | gettare | getta |
|---|---|---|
| Di base | La parola chiave throw passa manualmente il nostro oggetto eccezione creato a JVM. | La parola chiave throws viene utilizzata per delegare la responsabilità della gestione delle eccezioni al chiamante del metodo. |
| Sintassi | lanciare istanza Throwable; | return_type method_name (parameter-list) genera ExceptionClass_list { // corpo del metodo } |
| Seguito da | La parola chiave throw è seguita da un oggetto eccezione. | La parola chiave throws è seguita dall'elenco delle classi di eccezioni che possono verificarsi nel metodo. |
| Numero di eccezioni generate | La parola chiave throw può lanciare una singola istanza di eccezione. | La parola chiave throw può dichiarare più classi di eccezione separate da una virgola. |
Definizione di lancio
La parola chiave " throw " viene utilizzata per passare manualmente l'istanza di eccezione creata alla JVM (Java Virtual Machine) manualmente. Se "throw" non viene utilizzato per generare un'eccezione e l'eccezione si verifica, il sistema runtime inoltra internamente l'istanza di eccezione a JVM e il programma termina in modo anomalo. La forma generale della parola chiave throw è:
lanciare Throwable_instance;
Sopra la Throwable_instance deve essere un oggetto della classe Throwable. I tipi primitivi come int, float o char e l'istanza della classe non throwable non possono essere lanciati usando la parola chiave throw.
Facciamo un esempio per capire la parola chiave throw.
Class Test {Public static void main (String [] args) {throw new ArithmeticException ("/ per zero"); }} Nel codice precedente, la parola chiave throw genera un'istanza della classe Exception "ArithmeticException". Se la parola chiave throw non era stata utilizzata, il metodo main () avrebbe creato internamente un oggetto di eccezione consegnato alla JVM.
I punti da ricordare sul lancio della parola chiave:
- Passa manualmente l'oggetto eccezione alla JVM.
- Si utilizza al meglio per le eccezioni definite dall'utente o le eccezioni personalizzate.
- Se la memoria non è allocata all'oggetto eccezione generato dalla parola chiave throw, allora 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 istruzione dopo l'affermazione del lancio. Se scriviamo qualsiasi posizione direttamente dopo l'istruzione throw, il compilatore mostrerà un errore, istruzione irraggiungibile durante la compilazione.
- Solo gli oggetti della classe Throwable possono essere lanciati usando la parola chiave throw. Se l'oggetto lanciato non è un oggetto di classe Throwable, allora otteniamo un errore in fase di compilazione "Tipo trovato incompatibile. . richiesto java.lang.Throwable "
Nota:
La parola chiave throw è usata in C ++, JAVA, C #, per lanciare manualmente un'eccezione.
Definizione di tiri
La parola chiave " genera " viene utilizzata per delegare la responsabilità della gestione dell'eccezione verificatasi nel metodo, al suo metodo di chiamata. Il metodo del chiamante è responsabile della gestione dell'eccezione, potrebbe essere qualsiasi altro metodo o JVM. Dichiara l'elenco delle classi di eccezioni che possono verificarsi nel metodo.
L'utilizzo della parola chiave throws convince il compilatore che l'eccezione verificatasi nel metodo deve essere gestita dal metodo del chiamante, quindi non si verifica alcun errore di compilazione. Tuttavia, il metodo del chiamante deve gestire l'eccezione o delegare la responsabilità di gestire l'eccezione al suo metodo di gerarchia. Quando si verifica l'eccezione di runtime, anche dopo l'utilizzo della parola chiave throws, non impedisce la chiusura anomala del programma. Se il metodo del chiamante è main (), JVM di default gestisce l'eccezione.
La forma generale della parola chiave throws è:
return_type method_name (parameter-list) genera exceptionClass_list {// body of method} Possiamo vedere che la parola chiave throws 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.
Prendiamo un esempio per capire la parola chiave throw.
calss Test {public static void main (String [] args) genera InterruptedException {thread sleep (10000); }} Nel codice precedente, il thread principale viene reso disponibile per un po 'di tempo usando il metodo sleep (). Ora, quando il metodo principale è in stop, è possibile che gli altri thread possano interrompere il thread principale. Ma la parola chiave throws viene utilizzata dopo la firma del metodo main (), quindi il programma si compilerebbe facilmente. La parola chiave throws sta dichiarando la classe di eccezioni verificata InterruptedException. Ora, se qualsiasi altro thread interrompe il thread principale durante il runtime, la parola chiave throws passerà quell'eccezione al chiamante del metodo main (), che è JVM. La JVM avrebbe terminato il programma in modo anomalo.
I punti da ricordare sulla parola chiave:
- La parola chiave throws viene utilizzata solo per la dichiarazione delle classi di eccezioni verificate. L'utilizzo della parola chiave throws per un'eccezione non controllata non ha alcun impatto.
- Se il metodo non desidera gestire da solo l'eccezione, delega tale eccezione al metodo chiamante di quella classe utilizzando la parola chiave throws.
- Il suo utilizzo consente solo una facile compilazione del programma.
- Se si verifica un'eccezione in fase di runtime, il programma termina in modo anomalo, anche dopo l'utilizzo della parola chiave throws.
- Si consiglia di utilizzare il blocco try / catch per la terminazione normale del programma se si verifica un'eccezione in fase di runtime.
Nota:
La parola chiave viene usata solo in Java. C ++ e C # non usano la parola chiave throws.
Differenze chiave Tra lancio e lancio
- La parola chiave throw, consegna manualmente la responsabilità della gestione delle eccezioni a JVM manualmente mentre, la parola chiave lancia, passa la responsabilità della gestione delle eccezioni al metodo chiamante del codice in cui si è verificata un'eccezione.
- La parola chiave throw è seguita dall'oggetto exception che passa alla JVM. D'altra parte, la parola chiave throws è seguita dalle classi di eccezioni che possono verificarsi nel metodo.
- La parola chiave throw può lanciare un singolo oggetto eccezione alla volta, mentre la parola chiave throw può dichiarare più classi eccezione separate da una virgola alla volta.
Conclusione:
La parola chiave throw è utilizzata al meglio per l'eccezione personalizzata. Il blocco try / catch è la soluzione migliore per gestire le eccezioni rispetto alla parola chiave throws.
