Pengecualian Java Umum

1. Perkenalan

Tutorial ini berfokus pada beberapa pengecualian Java yang umum.

Kami akan mulai dengan membahas apa itu pengecualian pada dasarnya. Nanti, kita akan membahas berbagai jenis pengecualian yang dicentang dan yang tidak dicentang secara detail.

2. Pengecualian

Pengecualian adalah kondisi abnormal yang terjadi dalam urutan kode selama eksekusi program. Kondisi abnormal ini muncul ketika sebuah program melanggar batasan tertentu saat runtime.

Semua tipe pengecualian adalah subkelas dari kelas Exception . Kelas ini kemudian disubkelas menjadi pengecualian yang diperiksa dan pengecualian yang tidak dicentang. Kami akan mempertimbangkannya secara rinci di bagian selanjutnya.

3. Pengecualian yang Dicentang

Pengecualian yang dicentang wajib ditangani. Mereka adalah subclass langsung dari class Exception .

Ada perdebatan tentang pentingnya mereka yang patut untuk dilihat.

Mari tentukan beberapa pengecualian yang dicentang secara detail.

3.1. IOException

Sebuah metode melempar IOException atau subkelas langsungnya ketika operasi Input / Output gagal.

Penggunaan umum dari operasi I / O ini meliputi:

  • Bekerja dengan sistem file atau aliran data menggunakan paket java.io
  • Membuat aplikasi jaringan menggunakan paket java.net

FileNotFoundException

FileNotFoundException adalah tipe umum IOException saat bekerja dengan sistem file:

try { new FileReader(new File("/invalid/file/location")); } catch (FileNotFoundException e) { LOGGER.info("FileNotFoundException caught!"); }

Kesalahan formatURLException

Saat bekerja dengan URL, kami mungkin mengalami MalformedURLException - jika URL kami tidak valid.

try { new URL("malformedurl"); } catch (MalformedURLException e) { LOGGER.error("MalformedURLException caught!"); }

3.2. ParseException

Java menggunakan parsing teks untuk membuat objek berdasarkan String tertentu . Jika penguraian menyebabkan kesalahan, ParseException akan dilontarkan .

Misalnya, kita dapat merepresentasikan Tanggal dengan cara yang berbeda misalnya hh / bb / tttt atau hh, mm, tttt, tetapi coba parsing string dengan format yang berbeda:

try { new SimpleDateFormat("MM, dd, yyyy").parse("invalid-date"); } catch (ParseException e) { LOGGER.error("ParseException caught!"); }

Di sini, String salah format dan menyebabkan ParseException .

3.3. InterruptedException

Setiap kali thread Java memanggil join (), sleep () atau wait () , thread tersebut akan masuk ke status WAITING atau status TIMED_WAITING .

Selain itu, utas bisa menginterupsi utas lain dengan memanggil metode interupsi () utas lain .

Akibatnya, para benang melempar InterruptedException jika lain interupsi benang itu ketika sedang dalam TUNGGU atau di TIMED_WAITING negara.

Pertimbangkan contoh berikut dengan dua utas:

  • Utas utama memulai utas turunan dan memotongnya
  • Utas anak dimulai dan memanggil tidur ()

Skenario ini menghasilkan InterruptedException:

class ChildThread extends Thread { public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { LOGGER.error("InterruptedException caught!"); } } } public class MainThread { public static void main(String[] args) throws InterruptedException { ChildThread childThread = new ChildThread(); childThread.start(); childThread.interrupt(); } }

4. Pengecualian yang Tidak Dicentang

Untuk Pengecualian yang Tidak Dicentang, kompilator tidak memeriksa selama proses kompilasi. Karenanya, tidak wajib bagi metode untuk menangani pengecualian ini.

Semua pengecualian yang tidak dicentang memperluas kelas RuntimeException.

Mari kita bahas beberapa pengecualian yang tidak dicentang secara mendetail.

4.1. NullPointerException

Jika aplikasi mencoba menggunakan null di tempat yang sebenarnya memerlukan instance objek, metode tersebut akan menampilkan NullPointerException .

Ada beberapa skenario berbeda di mana penggunaan ilegal dari null menyebabkan NullPointerException. Mari kita pertimbangkan beberapa di antaranya.

Memanggil metode kelas yang tidak memiliki contoh objek:

String strObj = null; strObj.equals("Hello World"); // throws NullPointerException.

Selain itu, jika aplikasi mencoba mengakses atau memodifikasi variabel instance dengan referensi null , kita mendapatkan NullPointerException:

Person personObj = null; String name = personObj.personName; // Accessing the field of a null object personObj.personName = "Jon Doe"; // Modifying the field of a null object

4.2. ArrayIndexOutOfBoundsException

Sebuah array menyimpan elemennya dengan cara yang berdekatan. Dengan demikian, kita dapat mengakses elemennya melalui indeks.

Namun , jika sepotong kode mencoba mengakses indeks ilegal dari sebuah larik, masing-masing metode melontarkan ArrayIndexOutOfBoundException.

Mari kita lihat beberapa contoh yang memunculkan ArrayIndexOutOfBoundException :

int[] nums = new int[] {1, 2, 3}; int numFromNegativeIndex = nums[-1]; // Trying to access at negative index int numFromGreaterIndex = nums[4]; // Trying to access at greater index int numFromLengthIndex = nums[3]; // Trying to access at index equal to size of the array

4.3. StringIndexOutOfBoundsException

The String class in Java provides the methods to access a particular character of the string or to slice out a character array out of the String. When we use these methods, internally it converts the String into a character array.

Again, there could be an illegal use of indexes on this array. In such cases, these methods of the String class throws the StringIndexOutOfBoundsException.

This exception indicates that the index is either greater than or equal to the size of the String.StringIndexOutOfBoundsException extends IndexOutOfBoundsException.

The method charAt(index) of the class String throws this exception when we try to access a character at the index equal to the String's length or some other illegal index:

String str = "Hello World"; char charAtNegativeIndex = str.charAt(-1); // Trying to access at negative index char charAtLengthIndex = str.charAt(11); // Trying to access at index equal to size of the string 

4.4. NumberFormatException

Quite often an application ends up with numeric data in a String. In order to interpret this data as numeric, Java allows the conversion of String to numeric types. The wrapper classes such as Integer, Float, etc. contains utility methods for this purpose.

However, if the String doesn't have an appropriate format during the conversion, the method throws a NumberFormatException.

Let's consider the following snippet.

Here, we declare a String with an alphanumeric data. Further, we try to use the methods of the Integer wrapper class to interpret this data as numeric.

Consequently, this results in NumberFormatException:

String str = "100ABCD"; int x = Integer.parseInt(str); // Throws NumberFormatException int y = Integer.valueOf(str); //Throws NumberFormatException

4.5. ArithmeticException

When a program evaluates an arithmetic operation and it results in some exceptional condition, it throws ArithmeticException. In addition, ArithmeticException applies to only int and long data types.

For instance, if we try to divide an integer by zero, we get an ArithmeticException:

int illegalOperation = 30/0; // Throws ArithmeticException

4.6. ClassCastException

Java allows typecasting between the objects in order to support inheritance and polymorphism. We can either upcast an object or downcast it.

In upcasting, we cast an object to its supertype. And in downcasting, we cast an object to one of its subtypes.

However, at runtime, if the code attempts to downcast an object to a subtype of which it isn't an instance, the method throws a ClassCastException.

The runtime instance is what actually matters in typecasting. Consider the following inheritance between Animal, Dog, and Lion:

class Animal {} class Dog extends Animal {} class Lion extends Animal {} 

Further, in the driver class, we cast the Animal reference containing an instance of Lion into a Dog.

However, at the runtime, the JVM notices that instance Lion isn't compatible with the subtype of the class Dog.

This results in ClassCastException:

Animal animal = new Lion(); // At runtime the instance is Lion Dog tommy = (Dog) animal; // Throws ClassCastException

4.7. IllegalArgumentException

A method throws an IllegalArgumentException if we call it with some illegal or inappropriate arguments.

For instance, the sleep() method of the Thread class expects positive time and we pass a negative time interval as an argument. This results in IllegalArgumentException:

Thread.currentThread().sleep(-10000); // Throws IllegalArgumentException

4.8. IllegalStateException

IllegalStateException signals that a method's been invoked at an illegal or inappropriate time.

Every Java object has a state (instance variables) and some behavior (methods). Thus, IllegalStateException means it's illegal to invoke the behavior of this object with the current state variables.

However, with some different state variables, it might be legal.

For example, we use an iterator to iterate a list. Whenever we initialize one, it internally sets its state variable lastRet to -1.

With this context, the program tries to call the remove method on the list:

//Initialized with index at -1 Iterator intListIterator = new ArrayList().iterator(); intListIterator.remove(); // IllegalStateException 

Internally, the remove method checks the state variable lastRet and if it is less than 0, it throws IllegalStateException. Here, the variable is still pointing to the value -1.

Akibatnya, kami mendapatkan IllegalStateException .

5. Kesimpulan

Pada artikel ini, pertama kali kita membahas apa itu pengecualian. Sebuah pengecualian adalah suatu peristiwa, yang terjadi selama pelaksanaan program, yang mengganggu aliran normal instruksi program.

Kemudian, kami mengkategorikan pengecualian ke dalam Pengecualian yang Dicentang dan Pengecualian yang Tidak Dicentang.

Selanjutnya, kita membahas berbagai jenis pengecualian yang dapat muncul selama waktu kompilasi atau saat runtime.

Kami dapat menemukan kode untuk artikel ini di GitHub.