I Java är undantagshantering ett av de effektiva sätten att hantera runtime-fel så att det vanliga flödet av applikationen kan bevaras. Den hanterar runtime-fel som NullPointerException ArrayIndexOutOfBoundsException etc. För att hantera dessa fel effektivt tillhandahåller Java två nyckelord throw och throws.

Java kast

Nyckelordet throw i Java används för att uttryckligen kasta ett undantag från en metod eller något kodblock. Vi kan kasta antingen markerat eller omarkerat undantag. Nyckelordet throw används huvudsakligen för att skapa anpassade undantag. 

Syntax:

kasta Exempel

Där instans är ett objekt av typen Throwable (eller dess underklasser som Exception).

Exempel:

throw new ArithmeticException('/ med noll');

Men detta undantag d.v.s. instans måste vara av typen Kastbar eller en underklass av Kastbar . 

Flödet av exekvering av programmet stoppar omedelbart efter att throw-satsen exekveras och närmaste omslutande försök blocket kontrolleras för att se om det har en fånga uttalande som matchar typen av undantag. Om den finner en matchning kontrollerad överförs till det uttalandet annars nästa omslutande försök blocket är kontrollerat och så vidare. Om ingen matchning fånga hittas kommer standardundantagshanteraren att stoppa programmet. 

Exempel: Det här exemplet visar var ett undantag kastas upp och kastas om i en metod.

   class   Geeks     {      static     void     fun  ()      {      try     {      throw     new     NullPointerException  (  'demo'  );      }      catch     (  NullPointerException     e  )     {      System  .  out  .  println  (  'Caught inside fun().'  );      throw     e  ;     // rethrowing the exception      }      }      public     static     void     main  (  String     args  []  )      {      try     {      fun  ();      }      catch     (  NullPointerException     e  )     {      System  .  out  .  println  (  'Caught in main.'  );      }      }   }   

Caught inside fun(). Caught in main.  

Förklaring: Exemplet ovan visar användningen av nyckelordet throw för att explicit kasta en NullPointerException. Undantaget är fångat inuti gyckel() metod och kastas om där den sedan fångas upp i main()-metoden.

Exempel: Detta exempel visar ett aritmetiskt undantag.

   // Throwing an arithmetic exception   class   Geeks     {      public     static     void     main  (  String  []     args  ){      int     numerator     =     1  ;      int     denominator     =     0  ;      if     (  denominator     ==     0  )     {      // Manually throw an ArithmeticException      throw     new     ArithmeticException  (  'Cannot divide by zero'  );      }     else     {      System  .  out  .  println  (  numerator     /     denominator  );      }      }   }   

Produktion:

 Hangup (SIGHUP)   
 Exception in thread 'main' java.lang.ArithmeticException: Cannot divide by zero   
  at Geeks.main(Geeks.java:9)  
    Förklaring:    Ovanstående exempel visar ett undantag med användning av throw där ett ArithmeticException uttryckligen kastas på grund av division med noll.  
 
    Java kastar    
 
    kastar    är ett nyckelord i Java som används i signaturen av en metod för att indikera att den här metoden kan orsaka ett av de listade typundantagen. Den som anropar dessa metoder måste hantera undantaget med hjälp av ett försöksfångstblock.   
 
    Syntax:    
 
 
 typ metodnamn(parametrar) kastar undantagslista  
 
 
 där exception_list är en kommaseparerad lista över alla undantag som en metod kan skapa.  
 
 I ett program om det finns en chans att göra ett undantag varnar kompilatorn oss alltid om det och vi måste hantera det markerade undantaget. Annars får vi ett kompileringstidsfel som säger att det orapporterade undantaget XXX måste fångas eller förklaras kastas. För att förhindra detta kompileringstidsfel kan vi hantera undantaget på två sätt:   
 
 
 Genom att använda try catch  
 
 Genom att använda     kastar    nyckelord  
 
 
 Vi kan använda nyckelordet throws för att delegera ansvaret för undantagshantering till den som ringer (det kan vara en metod eller JVM) sedan är anroparmetoden ansvarig för att hantera det undantaget.    
 
    Exempel 1: Ohanterat undantag    
 Java   
   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      Thread  .  sleep  (  10000  );      System  .  out  .  println  (  'Hello Geeks'  );      }   }   
   
    Produktion:    
 
 error: unreported exception InterruptedException; must be caught or declared to be thrown  
    Förklaring:    I ovanstående program får vi kompileringstidsfel eftersom det finns en chans för undantag om huvudtråden ska sova andra trådar får chansen att köra main()-metoden som kommer att orsaka InterruptedException.   
 
    Exempel 2: Använda        throws         att hantera undantag    
 Java   
   class   Geeks     {      public     static     void     main  (  String  []     args  )      throws     InterruptedException      {      Thread  .  sleep  (  10000  );      System  .  out  .  println  (  'Hello Geeks'  );      }   }   
   
    Produktion:    
 
 Hello Geeks  
    Förklaring:    I programmet ovan hanterade vi genom att använda nyckelordet throws     InterruptedException    och vi kommer att få utdata som     Hej nördar.    
 
    Exempel 3:    Kasta ett undantag med   throws   
 Java   
   class   Geeks     {      static     void     fun  ()     throws     IllegalAccessException      {      System  .  out  .  println  (  'Inside fun(). '  );      throw     new     IllegalAccessException  (  'demo'  );      }      public     static     void     main  (  String     args  []  )      {      try     {      fun  ();      }      catch     (  IllegalAccessException     e  )     {      System  .  out  .  println  (  'Caught in main.'  );      }      }   }   
    
  Produktion   
Inside fun(). Caught in main.  
 
    Förklaring:    Ovanstående exempel kastar ett IllegalAccessException från en metod och hanterar det i huvudmetoden med hjälp av ett try-catch-block.  
 
 Skillnaden mellan kast och kast  
 
 De huvudsakliga skillnaderna mellan kast och kast i Java är följande:  
 
 
 
 
 
 kasta  
 
 
 
 kastar  
 
 
 
 
 
 
 
 Det används för att uttryckligen skapa ett undantag.  
 
 
 
 Den används för att förklara att en metod kan ge ett eller flera undantag.  
 
 
 
 
 
 Det används i en metod eller ett kodblock.  
 
 
 
 Den används i metodsignaturen.  
 
 
 
 
 
 Det kan kasta både markerade och omarkerade undantag.  
 
 
 
 Den används endast för markerade undantag. Omarkerade undantag kräver inte     kastar    
 
 
 
 
 
 Metoden eller blocket kastar undantaget.  
 
 
 
 Metodens anropare ansvarar för att hantera undantaget.  
 
 
 
 
 
 Stoppar det aktuella exekveringsflödet omedelbart.  
 
 
 
 Det tvingar den som ringer att hantera de deklarerade undantagen.  
 
 
 
 
 
 kasta ny ArithmeticException('Fel');  
 
 
 
 public void myMethod() kastar IOException {}