Sebagai pengembang Java, Anda harus memiliki pengetahuan yang baik tentang pengecualian Java dan penanganan pengecualian.
Tutorial ini memberikan pengetahuan dasar yang harus dimiliki setiap programmer saat bekerja dengan program Java. Untuk memulai, mari kita mulai dengan memahami apa sebenarnya Pengecualian Java itu.
Program Java dapat mengalami masalah yang mengakibatkan program dihentikan secara tiba-tiba selama eksekusinya. Masalah ini disebut pengecualian.
Seorang programmer yang baik harus dapat mengenali kesalahan yang mungkin terjadi selama eksekusi dan menyediakan rute alternatif untuk diambil program dalam kasus pengecualian tersebut. Praktik ini disebut penanganan pengecualian.
Sekarang Anda mungkin bertanya-tanya mengapa kita membutuhkan penanganan pengecualian sama sekali. Mengapa tidak menulis program yang tidak akan memberikan pengecualian?
Ternyata, menulis program yang tidak akan menghasilkan pengecualian tidaklah semudah kedengarannya. Sering kali, kesalahan yang tidak dapat dihindari ini berada di luar kendali programmer.
Program yang menerima masukan pengguna cenderung mengalami pengecualian karena masukan tidak valid yang diberikan pengguna. Begitu juga membaca file eksternal dengan mempertimbangkan kemungkinan bahwa mereka telah dipindahkan, diganti namanya, atau dihapus oleh sumber luar tanpa sepengetahuan programmer.
Dalam kasus seperti itu, program harus dapat menangani pengecualian dengan baik tanpa menghentikan eksekusi.
Semua pengecualian di Java harus merupakan turunan dari Exception
class, yang merupakan turunan dari Throwable
kelas.
Dua subclass utama dari Exception
kelasnya adalah RuntimeException
dan IOException
.
Kelas anak lain dari Throwable
kelasnya adalah Error
kelas. Namun, kesalahan berbeda dengan pengecualian.
Kesalahan menunjukkan masalah yang mungkin dialami JVM selama eksekusi. Masalah-masalah ini biasanya kritis dan tidak bisa diperbaiki. Kebocoran memori dan masalah ketidakcocokan perpustakaan adalah alasan umum kesalahan dalam program.
StackOverflowError
dan OutOfMemoryError
adalah dua contoh Kesalahan Java.
Kami dapat membagi Pengecualian Java menjadi dua kategori utama: diperiksa dan tidak dicentang pengecualian.
Pengecualian yang dicentang adalah pengecualian yang perlu ditangani dalam program sebelum dikompilasi. Jika pengecualian ini tidak ditangani, program tidak akan dikompilasi oleh compiler Java. Oleh karena itu, ini juga disebut pengecualian waktu kompilasi. IOExceptions
adalah contoh bagus dari pengecualian yang dicentang.
Pengecualian yang tidak dicentang adalah pengecualian yang diabaikan oleh kompilator saat menyusun program. Apakah kami telah menangani pengecualian ini dalam program atau tidak, tidak masalah kapan program dikompilasi. Karena penanganan pengecualian tidak dikenakan pada pengecualian ini, program kita dapat menjalankan RuntimeExceptions
yang mengakibatkan penghentian program.
Semua kelas yang memperpanjang RuntimeException
kelas adalah pengecualian yang tidak dicentang. Dua contoh kelas tersebut adalah NullPointerException
dan ArrayIndexOutOfBoundsException
.
Kami akan membahas beberapa metode yang umum digunakan di Java Exception
kelas:
getMessage
: mengembalikan pesan yang berisi detail tentang pengecualian yang terjadi.printStackTrace
: mengembalikan jejak tumpukan dari pengecualian yang terjadi.toString
: mengembalikan nama kelas dan pesan yang dikembalikan dengan getMessage
metode.Mari kita lihat bagaimana kita dapat menangani pengecualian di Java:
Kami dapat menangkap pengecualian dan menanganinya dengan benar menggunakan file coba tangkap blokir di Jawa.
Dalam sintaksis ini, bagian dari kode yang cenderung memunculkan pengecualian ditempatkan di dalam blok percobaan dan blok / blok penangkap menangkap pengecualian / pengecualian yang dilemparkan dan menanganinya sesuai dengan logika yang kami sediakan.
Sintaks dasar dari blok coba-tangkap adalah sebagai berikut:
try {
//exception-prone code } catch(Exception e) {
//error handling logic }
Dengan pendekatan ini, program tidak menghentikan eksekusi saat pengecualian dilemparkan oleh program, melainkan ditangani dengan baik.
Kita akan melihat cara menangani IOExceptions
dilempar oleh FileReader
kelas dalam program Java.
Contoh:
import java.io.FileReader; public class TryCatchBlockExample {
public static void main(String[] args) {
try {
FileReader file = new FileReader('source.txt');
file.read();
}
catch(Exception e) {
e.printStackTrace();
}
} }
Di sini, kami telah menggunakan satu blok catch untuk menangani FileNotFoundException
dilempar saat membuat instance FileReader
kelas dan IOException
dilempar oleh read()
metode FileReader
kelas.
Kedua pengecualian ini adalah turunan dari Exception
kelas.
Kita juga dapat menggunakan beberapa pernyataan tangkap untuk menangkap berbagai jenis kesalahan yang dilemparkan oleh kode di dalam pernyataan percobaan tunggal. Untuk contoh sebelumnya, kita bisa menggunakan satu blok catch untuk menangkap FileNotFoundException
dan blok tangkapan lainnya untuk IOException
seperti yang ditunjukkan cuplikan kode berikut:
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchBlockExample {
public static void main(String[] args) {
try {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
} }
Jika pengecualian yang dilempar cocok dengan pengecualian yang ditangani oleh pernyataan catch pertama, itu kemudian ditangani oleh logika di dalam pernyataan catch pertama.
Jika pengecualian tidak cocok, itu diteruskan ke pernyataan catch kedua. Jika ada lebih dari dua pernyataan catch, proses ini berlanjut hingga pengecualian mencapai pernyataan catch yang menangkap tipenya.
Sejak FileNotFoundException
adalah subtipe dari IOException
, menggunakan pernyataan catch kedua untuk menangkap FileNotFoundException
tidak akan berhasil. Ini akan ditangani oleh pernyataan catch pertama dan tidak pernah mencapai pernyataan ke-2.
Saat kami menggunakan file coba tangkap blok untuk menangkap pengecualian dalam program kami, ada contoh kami ingin menerapkan beberapa logika terlepas dari fakta apakah pengecualian ditangkap atau tidak. Dalam kasus seperti itu, kita dapat menggunakan file coba-tangkap-akhirnya blokir, bukan hanya file coba tangkap blok.
Kemudian, kode di dalam finally
pernyataan diimplementasikan apakah terjadi pengecualian atau tidak. finally
pernyataan harus selalu berada di akhir blok coba-tangkap-akhirnya.
Misalnya, saat kita menggunakan FileReader
kelas untuk membaca file, penting untuk menutup file yang dibuka di akhir pemrosesan apakah pengecualian terjadi atau tidak. Untuk memastikan ini, kita dapat menempatkan kode untuk menutup file di dalam finally
pernyataan.
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;
try {
file = new FileReader('source.txt');
file.read();
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
finally {
file.close();
}
} }
Namun, jika Anda mencoba untuk mengkompilasi kode di atas, kode tersebut tidak akan dapat dikompilasi karena tidak tertangani IOException
. Ini karena close()
metode FileReader
kelas juga bisa melempar IOExceptions
. Jadi, kita harus menempatkan bagian ini di dalam blok percobaan lain seperti ini:
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;
try {
file = new FileReader('source.txt');
file.read();
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
finally {
try {
file.close();
}
catch(IOException e) {
e.printStackTrace();
}
}
} }
Menangani error menggunakan throws
kata kunci di Java itu sederhana. Faktanya, dalam pendekatan ini, Anda tidak benar-benar menangani pengecualian di tempat terjadinya. Sebagai gantinya, kami membuang pengecualian dari metode saat ini ke metode yang memanggil metode saat ini. Kemudian, menangani kesalahan menjadi tanggung jawab metode luar.
Untuk membuang pengecualian dari suatu metode, Anda hanya perlu mendeklarasikan bahwa metode ini dapat memunculkan pengecualian yang dianggap. Mari kita lihat bagaimana kita bisa menangani IOExceptions
dilempar oleh FileReader
kelas menggunakan pendekatan ini.
Contoh:
import java.io.FileReader; import java.io.IOException; public class ThrowsExample {
public void readFile throws IOException {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
} }
Tidak seperti pendekatan lain dalam daftar ini, throw
kata kunci tidak digunakan untuk menangani kesalahan. Tapi karena kebanyakan orang bingung dengan throw
kata kunci dengan throws
kata kunci, kami pikir akan lebih baik jika membahasnya di sini.
throw
kata kunci digunakan untuk meminta pengecualian secara eksplisit. Kita bisa melempar eksepsi yang baru dipakai atau eksepsi yang tertangkap di dalam metode.
public class ThrowExample {
public void invalidate(int amount) throws Exception {
if (amount < 500) {
throw new Exception('Amount not sufficient');
}
} }
Selain menggunakan pengecualian Java bawaan, Anda dapat menentukan pengecualian Anda sendiri. Anda dapat mendefinisikannya sebagai pengecualian yang dicentang atau tidak dicentang. Untuk membuat pengecualian baru yang dicentang, pengecualian baru Anda harus memperluas Exception
kelas.
Untuk membuat file tidak diperiksa pengecualian, perpanjang RuntimeException
kelas.
Dalam contoh kode berikut, kami telah membuat pengecualian diperiksa yang ditentukan pengguna:
public class InvalidLengthException extends Exception {
private int length;
private String message;
public InvalidLengthException(int length, String message) {
this.length=length;
this.message=message;
}
public int getAmount() {
return this.length;
}
public String getMessage() {
return this.message;
} }
Sekarang kita dapat menggunakan pengecualian di atas di dalam logika program kita seperti ini:
public class InputChecker {
private int minLength;
private int maxLength;
public InputChecker(int minLength, int maxLength) {
this.minLength=minLength;
this.maxLength=maxLength;
}
public void checkStringLength(String strInput) throws InvalidLengthException {
int strLength = strInput.length();
if (strLength maxLength){
throw new InvalidLengthException(strLength, 'Input should have maximum '+maxLength+' character');
}
} }
Jika kita memeriksa panjang string menggunakan InputChecker
kelas, itu akan melempar InvalidLengthException
jika panjang string di bawah panjang minimum atau di atas panjang maksimum.
public class Main {
public static void main(String[] args) {
InputChecker ic = new InputChecker(2, 7);
try {
ic.checkStringLength('longer than the maximum length');
}
catch(InvalidLengthException e) {
e.printStackTrace();
}
} }
Ketika kita menjalankan potongan kode di atas, itu akan memunculkan InvalidLengthException
dan kami akan mendapatkan output berikut:
InvalidLengthException: Input should have maximum 7 character
at InputChecker.checkStringLength(InputChecker.java:17)
at Main.main(Main.java:6)
Dalam tutorial ini, kami memberi Anda pengantar singkat dan ringkas tentang Pengecualian Java. Kami berharap Anda sekarang memiliki pemahaman yang baik tentang apa itu pengecualian dan bagaimana menanganinya dalam program Java Anda.