Belajar Java Dasar(Keyword throw dan Keyword throws pada Exception Handling)

Pada artikel sebelumnya telah membahas mengenai beberapa keyword yang berhubungan dengan Exception Handling. Untuk selanjutnya masih ada keyword-keyword yang perlu kita ketahui dalam penggunaan Exception Handling. Keyword throw digunakan untuk melemparkan suatu bug yang dibuat secara manual dan Keyword throws digunakan dalam suatu metode atau kelas yang mungkin menghasilkan suatu kesalahan sehingga perlu ditangkap errornya. Pertama-tama kita akan membahas mengenai keyword throw. BErikut contoh programnya :

public class Contoh{ 
   public static void main(String []args){ 
      try{ 
         throw new Exception("kesalahan terjadi"); 
      }catch(Exception error){ 
         System.out.println(error); 
      } 
   } 
}

Output program: 
java.lang.Exception:kesalahan terjadi

Seperti yang anda lihat pada program diatas, pada keyword throw new Exception(“kesalahan terjadi”) akan melempar object bertipe exception yang merupakan subclass dari class Exception sehingga akan dianggap sebagai suatu kesalahan yang harus ditangkap oleh keyword catch. Perhatikan contoh berikut ini :

public class ContohException{ 
   ContohException(){
   } 
   public String toString(){ 
       return "Object dengan tipe class ContohException"; 
   } 
}

public class ContohMain{ 
   public static void main(String []args){ 
      try{ 
         throw new ContohException(); 
      }catch(Exception error){ 
         System.out.println(error); 
      } 
   } 
}

Output program: 
Object dengan tipe class ContohException

Program diatas telah mendefenisikan suatu kelas COntohException mengextends dari kelas Exception. Ketika kita melakukan throw new ContohException() maka object dari kelas bertipe ContohException ini akan diaggap kesalahan dan ditangkap oleh block catch.yang jadi pertanyaan adalah, coba anda menghilangkan keyword throw, apa yang akan terjadi berikutnya :

Kemudian untuk selanjutnya kita akan membahas keyword throws. Cara mendefenisikannya dalam metode adalah sebagai berikut: <method modifier> type method-name throws exception-list1, exceptio-list2, … {}.

Contoh program :

public class Contoh{ 
   public static void main(String[] args) { 
      try{ metodethrows(); 
      }catch(Exception error){ 
         System.out.println(error); 
      } 
   } 

   public static void metodethrows() throws NullPointerException,    
   ArrayIndexOutOfBoundsException{ 
      //implementasi method 
      throw new NullPointerException(); 
      //throw new ArrayIndexOutOfBoundsException(); 
   } 
}

Output Program : 
java.lang.NullPointerException

Contoh program lainnya :

public class Contoh2{ 
   public static void main(String[] args) { 
      try{ 
         f(); 
      } catch(Exception e) { 
         System.out.println(e); 
      } 
   } 
   public static void f() throws NullPointerException, ArrayIndexOutOfBoundsException { 
      //implementasi method 
      //throw new NullPointerException(); 
      throw new ArrayIndexOutOfBoundsException(); 
   } 
}

Output Program : 
java.lang.ArrayIndexOutOfBoundsException

Coba perhatikan kedua program dalam penggunaan keyword throws pada method. Ketika method tersebut dipanggil dalam block try. Maka method tersebut akan membuat object yang merupakan subclass dari class throwable dan method tersebut akan melemparkan kesalahan yang ada dalam block method kedalam block try. Di dalam block try, kesalahan tersebut kemudian ditangkap kedalam block catch.