De throw and throws is het concept van exception handling waarbij het throw-trefwoord de uitzondering expliciet uit een methode of een codeblok gooit, terwijl het throws-trefwoord wordt gebruikt bij de handtekening van de methode.
Er zijn veel verschillen tussen gooien En gooit trefwoorden. Hieronder vindt u een lijst met verschillen tussen worpen en worpen:
| Meneer nee. | Basis van verschillen | gooien | gooit |
|---|---|---|---|
| 1. | Definitie | Het Java-trefwoord throw wordt gebruikt om expliciet een uitzondering in de code te gooien, binnen de functie of het codeblok. | Het Java throws-sleutelwoord wordt gebruikt in de methodehandtekening om een uitzondering te declareren die door de functie kan worden gegenereerd tijdens de uitvoering van de code. |
| 2. | Type uitzondering Met het trefwoord throw kunnen we alleen ongecontroleerde uitzonderingen doorgeven, dat wil zeggen dat de gecontroleerde uitzondering niet kan worden doorgegeven met alleen throw. | Met behulp van het trefwoord throws kunnen we zowel aangevinkte als niet-gecontroleerde uitzonderingen declareren. Het trefwoord throws kan echter alleen worden gebruikt om gecontroleerde uitzonderingen door te geven. | |
| 3. | Syntaxis | Het trefwoord throw wordt gevolgd door een exemplaar van de uitzondering die moet worden gegenereerd. | Het trefwoord throws wordt gevolgd door klassenamen van de te genereren uitzonderingen. |
| 4. | Verklaring | worp wordt gebruikt binnen de methode. | worpen wordt gebruikt met de methodehandtekening. |
| 5. | Interne implementatie | We mogen slechts één uitzondering tegelijk genereren, dat wil zeggen dat we niet meerdere uitzonderingen kunnen genereren. | We kunnen meerdere uitzonderingen declareren met behulp van het trefwoord throws dat door de methode kan worden gegenereerd. main() genereert bijvoorbeeld IOException, SQLException. |
Java-worp voorbeeld
TestThrow.java
public class TestThrow { //defining a method public static void checkNum(int num) { if (num <1) { throw new arithmeticexception('
number is negative, cannot calculate square'); } else system.out.println('square of ' + num (num*num)); main method public static void main(string[] args) testthrow obj="new" testthrow(); obj.checknum(-3); system.out.println('rest the code..'); < pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/exception-handling/22/difference-between-throw.webp" alt="Difference between throw and throws in Java"> <h2>Java throws Example</h2> <p> <strong>TestThrows.java</strong> </p> <pre> public class TestThrows { //defining a method public static int divideNum(int m, int n) throws ArithmeticException { int div = m / n; return div; } //main method public static void main(String[] args) { TestThrows obj = new TestThrows(); try { System.out.println(obj.divideNum(45, 0)); } catch (ArithmeticException e){ System.out.println('
Number cannot be divided by 0'); } System.out.println('Rest of the code..'); } } </pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/exception-handling/22/difference-between-throw-2.webp" alt="Difference between throw and throws in Java"> <h2>Java throw and throws Example</h2> <p> <strong>TestThrowAndThrows.java</strong> </p> <pre> public class TestThrowAndThrows { // defining a user-defined method // which throws ArithmeticException static void method() throws ArithmeticException { System.out.println('Inside the method()'); throw new ArithmeticException('throwing ArithmeticException'); } //main method public static void main(String args[]) { try { method(); } catch(ArithmeticException e) { System.out.println('caught in main() method'); } } } </pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/exception-handling/22/difference-between-throw-3.webp" alt="Difference between throw and throws in Java"> <hr></1)> Uitgang:
Java-worp en gooit Voorbeeld
TestThrowAndThrows.java
public class TestThrowAndThrows { // defining a user-defined method // which throws ArithmeticException static void method() throws ArithmeticException { System.out.println('Inside the method()'); throw new ArithmeticException('throwing ArithmeticException'); } //main method public static void main(String args[]) { try { method(); } catch(ArithmeticException e) { System.out.println('caught in main() method'); } } } Uitgang:
