Aanbevolen, 2021

Editor'S Choice

Verschil tussen gooien en gooien in Java

De worpen en worpen zijn de sleutelwoorden die worden gebruikt bij het afhandelen van uitzonderingen. Het throw- trefwoord wordt gebruikt om de instantie van de uitzondering die door de programmeur handmatig is gemaakt, over te dragen aan de JVM. Het worp- sleutelwoord dat wordt gebruikt om de verantwoordelijkheid voor het omgaan met de uitzondering over te dragen, vond plaats in de methode volgens de beller-methode. Het belangrijkste verschil tussen de worp en de worp is dat het worp-sleutelwoord het uitzonderingsobject gebruikt, terwijl het worp-sleutelwoord de naam van de uitzonderingsklassen gebruikt.

Vergelijkingstabel

Basis voor vergelijkinggooienworpen
basis-Het throw-sleutelwoord overhandigt ons gecreëerde uitzonderingsobject handmatig aan JVM.Het worp-sleutelwoord wordt gebruikt om de verantwoordelijkheid voor de afhandeling van uitzonderingen aan de beller van de methode te delegeren.
Syntaxisgooi Throwable-instantie;return_type method_name (parameter-lijst) gooit ExceptionClass_list
{
// body of methode
}
Gevolgd doorHet worp-sleutelwoord wordt gevolgd door een uitzonderingsobject.Het worp-sleutelwoord wordt gevolgd door de lijst met uitzonderingsklassen die in de methode kunnen voorkomen.
Aantal gegooide uitzonderingenHet throw-trefwoord kan een enkele uitzonderingsinstantie genereren.Met het sleutelwoord voor worpen kunnen meerdere uitzonderingsklassen worden onderscheiden, gescheiden door een komma.

Definitie van gooien

Het sleutelwoord " throw " wordt gebruikt om onze gecreëerde exception-instantie handmatig over te dragen aan de JVM (Java Virtual Machine). Als "throw" niet wordt gebruikt om een ​​uitzonderingsinstantie te gooien en de uitzondering optreedt, dan gooit het runtimesysteem intern de exception-instantie naar JVM en eindigt het programma abnormaal. De algemene vorm van het worp-sleutelwoord is:

 gooi Throwable_instance; 

Boven de Throwable_instance moet een object van de klasse Throwable staan. Primitieve typen zoals int, float of char en de niet-gooibare klasse-instantie kunnen niet worden gegooid met behulp van throw-trefwoord.

Laten we een voorbeeld nemen om de sleutelwoordworp te begrijpen.

 Class Test {Public static void main (String [] args) {gooi nieuwe ArithmeticException ("/ by zero"); }} 

In bovenstaande code gooit de sleutelwoordgworp een exemplaar van de Uitzonderingsklasse "ArithmeticException". Als het throw-trefwoord niet was gebruikt, had de methode main () intern een exception-object gemaakt dat aan de JVM werd overgedragen.

De punten om te onthouden over de trefwoordgame:

  • Het geeft het uitzonderingsobject handmatig over aan de JVM.
  • Het wordt het best gebruikt voor de door de gebruiker gedefinieerde uitzonderingen of aangepaste uitzonderingen.
  • Als het geheugen niet is toegewezen aan het uitzonderingsobject dat is gegooid met throw-sleutelwoord, treedt er een runtime-uitzondering op, NullPointerException.
  • Het worp-sleutelwoord stopt de uitvoering van het programma onmiddellijk na het optreden ervan. we kunnen niet direct een statement schrijven na het throw-statement. Als we een staement direct na throw-instructie schrijven, geeft de compiler tijdens de compilatie een fout, een onbereikbare verklaring.
  • Alleen objecten van de klasse Throwable kunnen worden gegooid met het zoekwoord throw. Als het object dat wordt gegooid geen object is van klasse Throwable, krijgen we een fout in de compile-tijd "Type incompatibel gevonden. . vereist java.lang.Throwable "

Notitie:

Het worp-sleutelwoord wordt gebruikt in C ++, JAVA, C #, om handmatig een uitzondering te gooien.

Definitie van worpen

Het sleutelwoord " worpen " wordt gebruikt om de verantwoordelijkheid voor het afhandelen van de in de methode opgetreden uitzondering te delegeren aan de methode van de beller. De beller-methode is verantwoordelijk voor het afhandelen van de uitzondering, het kan elke andere methode of JVM zijn. Het verklaart de lijst met uitzonderingsklassen die in de methode kunnen voorkomen.

Het gebruik van het worp-sleutelwoord overtuigt de compiler dat de uitzondering in de methode is opgetreden om te worden afgehandeld door de beller-methode en daarom vindt er geen compilatiefout plaats. Maar de methode van de beller moet de uitzondering afhandelen of de verantwoordelijkheid delegeren om de uitzondering op de hiërarchiemethode af te handelen. Wanneer de runtime-uitzondering optreedt, voorkomt deze zelfs na het gebruik van het worp-zoekwoord niet dat het programma abnormaal wordt beëindigd. Als de beller-methode main () is, verwerkt de standaard JVM de uitzondering.

De algemene vorm van het worp-sleutelwoord is:

 return_type methode_naam (parameter-lijst) gooit exceptionClass_list {// body of methode} 

We kunnen zien dat het worp-zoekwoord wordt weergegeven na de handtekening van de methode en het kan de lijst bevatten met uitzonderingsklassen die in de methode kunnen voorkomen. De lijst met uitzonderingsklassen geschreven na het genereren van het sleutelwoord wordt gescheiden door de komma.

Laten we een voorbeeld nemen om het worp-zoekwoord te begrijpen.

 calss Test {public static void main (String [] args) gooit InterruptedException {thread sleep (10000); }} 

In de bovenstaande code wordt de hoofddraad een tijd lang geslapen met behulp van de methode sleep (). Nu, wanneer de hoofdmethode in slaap is, is het mogelijk dat de andere threads de hoofddraad kunnen onderbreken. Maar het worp-sleutelwoord wordt gebruikt na de handtekening van de main () -methode, dus het programma zou gemakkelijk kunnen worden gecompileerd. Het worp-sleutelwoord declareert de gecontroleerde uitzonderingsklasse Onderbroken Belasting. Als een andere thread de hoofdthread onderbreekt tijdens runtime, zou het worp-sleutelwoord die uitzondering overhandigen aan de beller van de main () -methode, JVM. De JVM zou het programma abnormaal beëindigen.

De punten om te onthouden over het worp-zoekwoord:

  • Het worp-sleutelwoord wordt alleen gebruikt voor het declareren van de gecontroleerde uitzonderingsklassen. Het gebruik van het worp-sleutelwoord voor een niet-gecontroleerde uitzondering heeft geen invloed.
  • Als de methode de uitzondering niet zelfstandig wil afhandelen, delegeert het die uitzondering naar de beller-methode van die klasse met behulp van het worp-sleutelwoord.
  • Het gebruik ervan maakt alleen een vlotte compilatie van het programma mogelijk.
  • Als er tijdens runtime een uitzondering optreedt, wordt het programma abnormaal afgesloten, zelfs na het gebruik van het worp-zoekwoord.
  • Het wordt aanbevolen om try / catch-blok te gebruiken voor normale beëindiging van het programma als er tijdens runtime een uitzondering optreedt.

Notitie:

Het trefwoord gooit alleen gebruikt in Java. C ++ en C # gebruiken het worp-sleutelwoord niet.

Belangrijkste verschillen tussen worpen en worpen

  1. Het trefwoord gooien, de verantwoordelijkheid voor het afhandelen van uitzonderingen overhandigen aan JVM handmatig, terwijl het trefwoord gooit, de verantwoordelijkheid van de afhandeling van uitzonderingen overhandigen aan de beller-methode van de code waar een uitzondering is opgetreden.
  2. Het worp-sleutelwoord wordt gevolgd door het uitzonderingsobject dat wordt overgedragen aan de JVM. Aan de andere kant wordt worp-trefwoord gevolgd door de uitzonderingsklassen die kunnen voorkomen in de methode.
  3. Het throw-sleutelwoord kan tegelijk een exception-object werpen, terwijl het throw-sleutelwoord meerdere exceptionklassen kan declareren, gescheiden door een komma per keer.

Conclusie:

Het worp-sleutelwoord wordt het best gebruikt voor de aangepaste uitzondering. Het try / catch-blok is het beste voor het afhandelen van uitzonderingen in vergelijking met het worpen-zoekwoord.

Top