• Program perlu bekerja secara stabil (terutama sekali saat mengendalikan embedded systems, bidang dimana Java awalnya digunakan).
• Pemrogram dapat menulis banyak pernyataan kondisi untuk memeriksa keabsahan (valid tidaknya) input, tetapi:
Sulit dalam pemeliharaan, karena kode yang menangani kejadian exceptional (pengecualian) bercampur baur dengan kode untuk menangani operasi program normal;
Kode tambahan dapat secara dramatis memperbesar ukuran dari program.
• Java mempunyai mekanisme exception handling yang mengalamati masalah-masalah di atas.
• Dalam Java, terdapat perbedaan antara exception dan error: Exception – suatu situasi tidak biasa yang dapat di atasi dengan mudah, situasi ini dapat diperkirakan saat perancangan. Contohnya adalah percobaan untuk membaca data dari suatu file yang tidak dapat ditemukan.
Error – suatu kondisi yang tidak dapat diperbaiki atau solusinya masih memerlukan perbaikan pada bagian di lura program yang ditulis. Contoh kondisi ini adalah running out of memory.
• Exception handling (penanganan pengecualian) ditengahi oleh obyek class java.lang.Exception (atau salah satu dari subclassnya).
• Obyek tersebut dibangkitkan oleh kode yang mendeteksi bahwa suatu kondisi “tidak biasa” terjadi – dikatakan melempar (throw) exception.
• Kode lain bertanggungjawab untuk menangkap exception (mengambil suatu tindakan untuk mengurusinya, atau sekedar mengabaikannya).
• Obyek thrown exception biasanya mengalami beberapa lapisan kode exception-catching sampai suatu exception handler yang cocok ditemui.
Blok try…catch
• Exception handling ditempatkan di dalam blok try…catch:
try {
// pernyataan yang mungkin menyebabkan exception // ...
}
catch (Exception e) {
// tangani obyek exception e // ...
}
• Throw dan catch secara efektif merupakan bentuk lain dari struktur kendali (control structure) dalam Java.
• Aliran kendali dimulai dari titik dimana exception dilempar (thrown) dan dilanjutkan pada tempat ditangkap (catch). • Suatu kode yang mengikuti blok try…catch dieksekusi secara
normal (kecuali tindakan dari blok catch adalah keluar dari program).
Contoh
public class TestException1 {
try { p[0] = “John Lennon”; p[2] = “Paul McCartney”; p[4] = “George Martin”; p[1] = “Ringo Starr”; p[3] = “George Harrison”; } catch (ArrayIndexOutOfBoundsException e) { System.out.println(“There were only four Beatles”);
}
for (int i=0; i<p.length; i++) System.out.println(p[i]); }
}
• Keluaran dari program TestException1 di atas adalah
There were only four Beatles John Lennon
null
Paul McCartney null
ada yang aneh, Mengapa?
Menangkap Banyak Exception
• Berikut ini adalah contoh yang lebih artificial!
• Program ini menggunakan generator (pembangkit) bilangan acak (random) untuk mengatur nilai suatu pembagi integer menjadi 0 atau 1 (dengan peluang yang sama).
• Saat bernilai nol, suatu ArithmeticException dimunculkan ketika ada usaha untuk membagi (karena pembagian dengan nol menghasilkan error, secara matematis memberikan nilai tak terhingga).
• Saat bernilai satu, diperoleh exception indeks array seperti sebelumnya.
import java.util.Random; public class TestException2 {
public static void main(String[] args) { String[] p = new String[4];
try {
Random r = new Random(); int divisor=0; if (r.nextGaussian()>0) divisor=1; double x = 1/divisor; p[0] = “John Lennon”; p[2] = “Paul McCartney”; p[4] = “George Martin”; p[1] = “Ringo Starr”; p[3] = “George Harrison”; } catch (ArrayIndexOutOfBoundsException e) { System.out.println(“There were only four Beatles”);
}
catch (ArithmeticException e) {
System.out.println(“Divide by zero”); }
System.out.println(“But lets continue anyway”); }
}
• Keluaran dari program di atas dapat berupa:
There were only four Beatles But lets continue anyway
atau
Divide by zero
But lets continue anyway
• Sintaks try…catch menyediakan suatu cata teratur dari penanganan lebih dari satu exception;
• Pemrogram tidak pernah melempar kedua exception dalam suatu giliran tunggal (single run), karena aliran kontrol dilempar ke blok catch dan kemudian ke ujung dari blok try…catch lengkap.
• Pemrogram dapat menangkap kedua exception dalam suatu pernyataan tunggal (hanya dengan class Exception) karena ArrayIndexOutOfBoundsException dan ArithmeticException merupakan subclass dari Exception:
catch (Exception e) { // lakukan sesuatu }
• Ini merupakan cara mudah dan tepat untuk menangani banyak exception sekaligus, misalnya meminta program keluar (selesai) walaupun dapat dikatakan sebagai langkah yang “malas”.
Menggunakan Instance Exception
• Pemrogram mempunyai akses ke instance Exception dan dapat salah satu:
Melemparnya kembali, misalnya ke suatu blok lebih luar dari kode exception-handling;
Mencetak informasi diagnosis.
• Pada pilihan terakhir, digunakan metode printStackTrace milik class Exception.
catch (ArithmeticException e) {
System.out.println(“Divide by zero”); e.printStackTrace();
}
• Ini memberikan informasi berharga, tertama jika exception terjadi dalam kode bersarang yang dalam:
Divide by zero
java.lang.ArithmeticException: / by zero
at TestException2.main(TestException2.java:9) But lets continue anyway
Exception ‘bubbling up’ (throwing up?)
• Jika tidak disediakan suatu handler yang tepat atau menghilangkan blok try...catch maka exception dilempar ke metode yang menjalankan metode tempat exception terjadi. • Jika metode yang menjalankan mempunyai handler yang
tepat, exception ditangani pada titik itu, jika tidak maka proses berulang sampai metode top-level (main) dicapai.
public class TestException3 {
public static void main(String[] args) { try {
method1(); } catch (ArithmeticException e) { System.out.println(“divide by zero”); e.printStackTrace(); } } // end of main
public static void method1() { double index = 5/0;
}
} // end of class
Eksekusinya memberikan hasil:
divide by zero
java.lang.ArithmeticException: / by zero
at TestException3.method1(TestException3.java:11) at TestException3.main(TestException3.java:4)
Checked Exception
• Java mempunyai dua jenis exception, checked dan unchecked.
• Compiler mendorong pemrogram menyediakan suatu
exception handler untuk yang terlebih dahulu, tetapi tidak yang belakangan
• Sebagian besar exception diimplementasikan oleh
programmer adalah checked, sebagaimana yang
diperkenalkan Java sendiri:
Exception harus ditangkap pada beberapa titik dalam program;
Suatu metode yang mempunyai potensi untuk
membangkitkan suatu checked exception yang tidak ditangkap secara lokal (dalam metode) harus menyatakan bahwa exception akan dilempar.
• Contoh: metode readFile() mungkin membangkitkan suatu EOFException. Jika exception tidak ditangani dalam metode itu sendiri, maka harus mempunyai signature:
public void readFile(String s) throws EOFException { ...
Penyertaan metode yang tidak menangani exception harus pula mengandung pernyataan bahwa metode melemparnya.
Unchecked Exception
• Tidak ada kemungkinan untuk meminta pemrogram
memeriksa setiap kemungkinan tipe exception.
• Sebagai contoh, compiler tidak mengharuskan bahwa suatu ArrayIndexOutOfBoundsException ditangkap.
• Q. Mengapa ini menjadi tidak praktis?
• Semua exception yang merupakan subclass dari
java.lang.RuntimeException atau java.lang.Error adalah unchecked.
• Tidak ada ebutuhan untuk mengingat mana exception yang checked dan mana yang unchecked - compiler akan memberitahu jika suatu checked exception belum ditangani.
Mendeklarasikan Exception Sendiri
• Sebagian besar aplikasi perlu menghandle kondisi exceptional-nya sendiri, misalnya program catur (chess) akan melempar suatu exception jika dua bidak dipindahkan ke kotak yang sama.
• Pemrogram mendefinisikan exception sendiri dengan mengembangkan class java.lang.Exception.
• Secara konvensi, pemrogram hanya perlu menyediakan: Contructor default (tanpa parameter);
Contructor dengan suatu parameter String tunggal. • Contoh: Hirarki exception umur:
Implementasi Hirarki Exception Umur
public class ExceptionUmur extends Exception { public ExceptionUmur() { super(); } public ExceptionUmur(String s) { super(s); } }
public class ExceptionTerlaluMuda extends ExceptionUmur { public ExceptionTerlaluMuda() { super(); } public ExceptionTerlaluMuda(String s) { super(s); } }
public class ExceptionTerlaluTua extends ExceptionUmur { public ExceptionTerlaluTua() { super(); } public ExceptionTerlaluTua(String s) { super(s); } }
Menggunakan Exception Umur
try {
EasyReader keyboard = new EasyReader();
int umur = keyboard.readInt(“Masukkan umur: “); if (umur > 70)
throw new ExceptionTerlaluTua(“Terlalu tua untuk ikut panjat tebing”);
throw new ExceptionTerlaluMuda(“Terlalu muda kalau harus pergi”); } catch (ExceptionUmur e) { e.printStackTrace(); }
Output kalau variabel umur bernilai 2
ExceptionTerlaluMuda: Terlalu muda kalau harus pergi at TrivialApplication.main(ProgramUmur.java) Output jika variabel umur bernilai 90
ExceptionTerlaluTua: Terlalu tua untuk ikut panjat tebing at TrivialApplication.main(ProgramUmur.java)
Finally, akhirnya…
• Pemrogram sering (perlu) melakukan beberapa ‘cleaning up’ setelah melempar suatu exception, misalnya menutup koneksi ke file dan database.
• Duplikasi kode dalam blok catch berbeda sebaiknya dihindari. Java menyediakan suatu blok optional finally yang pasti selalu dieksekusi, tidak peduli apakah exception di- thrown, di-catch atau tidak.
try { // seperti sebelumnya } catch (AgeException e) { // seperti sebelumnya } finally {
System.out.println(“Maaf…ini hanya contoh.”); }
Output jika umut yang dimasukkan adalah 80
ExceptionTerlaluTua: Terlalu tua untuk ikut panjat tebing at AgeApplication.main(ProgramUmur.java)
Maaf…ini hanya contoh.
Output jika umur yang dimasukkan 35
Rangkuman
• Exception adalah kondisi yang mempunyai potensi untuk dapat direcover sedangkan error secara umum tidak dapat diselesaikan.
• Kode yang dapat membangkitan exception sebaiknya diletakkan di dalam blok try…catch…finally.
• Beberapa exception bersifat checked, dan lainnya unchecked. Checked exception harus ditangani oleh programmer.
• Pemrogram dapat membuat class exception sendiri dengan mengembangkan class java.lang.Exception.
• Suatu kode yang diletakkan di dalam blok finally akan
dieksekusi sebelum kontrol meninggal blok
try…catch…finally, tanpa memperhatikan apakah suatu exception dilempar atau ditangkap.