Pengecualian Java Biasa

1. Pengenalan

Tutorial ini memberi tumpuan kepada beberapa pengecualian Java yang biasa.

Kita akan mulakan dengan membincangkan apa pengecualian pada dasarnya. Kemudian, kami akan membincangkan pelbagai jenis pengecualian yang diperiksa dan tidak dicentang secara terperinci.

2. Pengecualian

Pengecualian adalah keadaan tidak normal yang berlaku dalam urutan kod semasa pelaksanaan program. Keadaan tidak normal ini timbul apabila program melanggar batasan tertentu pada waktu runtime.

Semua jenis pengecualian adalah subkelas Pengecualian kelas . Kelas ini kemudian dikelaskan dalam pengecualian yang diperiksa dan pengecualian yang tidak dicentang. Kami akan mempertimbangkannya secara terperinci di bahagian seterusnya.

3. Pengecualian yang diperiksa

Pengecualian yang diperiksa adalah wajib untuk dikendalikan. Mereka adalah subkelas langsung Pengecualian kelas .

Terdapat perdebatan mengenai kepentingan mereka yang perlu dilihat.

Mari tentukan beberapa pengecualian yang diperiksa secara terperinci.

3.1. Pengecualian IO

Kaedah membuang IOException atau subkelas langsung daripadanya apabila operasi Input / Output gagal.

Penggunaan biasa operasi I / O ini termasuk:

  • Bekerja dengan sistem fail atau aliran data menggunakan pakej java.io
  • Membuat aplikasi rangkaian menggunakan pakej java.net

FileNotFoundException

FileNotFoundException adalah jenis IOException yang biasa semasa bekerja dengan sistem fail:

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

KesalahanURLException

Semasa bekerja dengan URL, kami mungkin menghadapi MalformedURLException - jika URL kami tidak sah.

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

3.2. ParseException

Java menggunakan penghuraian teks untuk membuat objek berdasarkan String tertentu . Sekiranya penghuraian menyebabkan ralat, ia akan membuang ParseException .

Sebagai contoh, kita dapat mewakili Tarikh dengan cara yang berbeza seperti dd / mm / yyyy atau dd, mm, yyyy, tetapi cuba menguraikan rentetan dengan format yang berbeza:

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

Di sini, String salah bentuk dan menyebabkan ParseException .

3.3. Terganggu Pengecualian

Setiap kali panggilan thread Java bergabung (), tidur () atau menunggu () ia masuk ke keadaan MENUNGGU atau keadaan TIMED_WAITING .

Sebagai tambahan, utas boleh mengganggu utas lain dengan memanggil kaedah interrupt () thread lain .

Akibatnya, yang thread melemparkan yang InterruptedException jika lain sampukan thread semasa ia berada di MENUNGGU atau dalam TIMED_WAITING negeri.

Pertimbangkan contoh berikut dengan dua utas:

  • Benang utama memulakan utas kanak-kanak dan mengganggu
  • Benang kanak-kanak bermula dan memanggil tidur ()

Senario ini menghasilkan InterceptionException:

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 Diperiksa

Untuk Pengecualian Tidak Diperiksa, penyusun tidak memeriksa semasa proses penyusunan. Oleh itu, kaedah untuk menangani pengecualian ini tidak diwajibkan.

Semua pengecualian yang tidak dicentang memperpanjang kelas RuntimeException.

Mari kita bincangkan beberapa pengecualian yang tidak diperiksa secara terperinci.

4.1. NullPointerException

Sekiranya aplikasi cuba menggunakan null di mana ia benar-benar memerlukan contoh objek, kaedah akan membuang NullPointerException .

Terdapat senario yang berbeza di mana penggunaan null secara haram menyebabkan NullPointerException. Mari kita pertimbangkan beberapa daripadanya.

Memanggil kaedah kelas yang tidak mempunyai contoh objek:

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

Juga, jika aplikasi cuba mengakses atau mengubah pemboleh ubah instance dengan rujukan nol , kami mendapat 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

Array menyimpan unsur-unsurnya secara bersebelahan. Oleh itu, kita dapat mengakses unsur-unsurnya melalui indeks.

Walau bagaimanapun , jika sekeping kod cuba mengakses indeks larik larik, kaedah masing-masing melemparkan ArrayIndexOutOfBoundException.

Mari kita lihat beberapa contoh yang membuang 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.

Hasilnya, kami mendapat IllegalStateException .

5. Kesimpulan

Dalam artikel ini, pertama-tama kita membincangkan apa pengecualian. Satu pengecualian adalah acara, yang berlaku semasa pelaksanaan program, yang mengganggu aliran biasa arahan program.

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

Seterusnya, kami membincangkan pelbagai jenis pengecualian yang boleh muncul semasa waktu penyusunan atau pada waktu proses.

Kita boleh mendapatkan kod artikel ini di GitHub.