JAVA: Exception

Exception Handling di Java adalah salah satu cara yang efektif untuk menangani kesalahan runtime sehingga aliran reguler aplikasi dapat dipertahankan. Java Exception Handling adalah mekanisme untuk menangani kesalahan runtime seperti ClassNotFoundException, IOException, SQLException, RemoteException, dll.

Exception adalah peristiwa yang tidak diinginkan atau tidak terduga, yang terjadi selama eksekusi program yaitu pada saat dijalankan, yang mengganggu aliran normal instruksi program. Exception dapat ditangkap dan ditangani oleh program. Ketika exception terjadi dalam suatu method, ini akan menciptakan sebuah object. Object ini disebut exception object. Ini berisi informasi tentang exception seperti nama dan deskripsi exception dan status program saat exception terjadi.

Penyebab utama mengapa sebuah exception terjadi

Input user yang salah/invalid
Kegagalan Device
Loss dari sambungan network
Keterbatasan fisik (out of disk memory)
Error code
Membuka file yang tidak ada

Errors mewakili kondisi yang tidak dapat dipulihkan seperti Java virtual machine (JVM) kehabisan memori, memory leaks, stack overflow errors, library incompatibility, infinite recursion, dll. Kesalahan biasanya di luar kendali programmer dan kita sebaiknya tidak mencoba menangani error.

Mari kita bahas bagian terpenting yang merupakan perbedaan antara Error dan Exception yaitu sebagai berikut:

Error: Kesalahan menunjukkan masalah serius yang sebaiknya tidak ditangkap oleh aplikasi yang baik.
Exception: menunjukkan kondisi yang mungkin dapat / dicoba ditangkap oleh aplikasi yang wajar.

Hirarki Exception

Semua jenis exception dan error adalah subclass dari class Throwable, yang merupakan base class dari sebuah hirarki. Satu cabang adalah Exception. Class ini digunakan untuk kondisi luar biasa yang harus ditangkap oleh program. NullPointerException adalah contoh pengecualian semacam itu. Cabang lain, Error digunakan oleh Java run-time system (JVM) untuk menunjukkan error yang berkaitan dengan run-time environment itu sendiri (JRE). StackOverflowError adalah contoh error tersebut.

Exception Hierarchy in Java

Tipe Exception

Java mendefinisikan beberapa jenis exception yang berhubungan dengan berbagai class library. Java juga memungkinkan pengguna untuk menentukan exception mereka sendiri.

Types of Exceptions

Exception dapat di kategorikan dalam dua hal:

Built-in Exception
- Checked Exception
- Unchecked Exception
User-Defined Exception

Mari kita bahas pengecualian terdaftar yang ditentukan di atas yaitu sebagai berikut:

Built-in Exception:

Built-in exception adalah exception yang tersedia di Java Library. Exception ini cocok untuk menjelaskan situasi error tertentu.

Checked Exception: Exception yang diperiksa disebut compile-time exception karena exception ini diperiksa pada waktu kompilasi oleh kompiler.
Unchecked Exception: Unchecked exception berlawanan dengan Checked exception. Kompiler tidak akan memeriksa exception ini pada waktu kompilasi. Dengan kata sederhana, jika sebuah program mengeluarkan unchecked exception, dan bahkan jika kita tidak menangani atau mendeklarasikannya, program tersebut tidak akan memberikan error kompilasi.

User-Defined Exception:

Terkadang, built-in exception di Java tidak dapat menggambarkan situasi tertentu. Dalam kasus seperti itu, pengguna juga dapat membuat exception yang disebut 'user-defined Exception'.

Kelebihan Exception Handling di Java adalah sebagai berikut:

Ketentuan untuk Menyelesaikan Eksekusi Program
Identifikasi Kode Program dan Kode Penanganan Error yang Mudah
Penyebaran Kesalahan
Pelaporan Kesalahan yang Berarti
Mengidentifikasi Jenis Kesalahan

Bagaimana JVM menangani Exception?

Default Exception Handling: Kapan pun di dalam suatu method, jika exception telah terjadi, method tersebut membuat Object yang dikenal sebagai Exception Object dan menyerahkannya ke run-time system (JVM). Exception object berisi nama dan deskripsi exception dan status program saat ini di mana exception telah terjadi. Membuat Exception Object dan menanganinya dalam run-time system disebut throwing an Exception. Mungkin ada daftar method yang dipanggil untuk sampai ke method di mana exception terjadi. Daftar method yang diurutkan ini disebut Call Stack. Selanjutnya, prosedur berikut akan terjadi.

Run-time system mencari call stack untuk menemukan method yang berisi block code yang dapat menangani exception yang terjadi. Block code tersebut disebut Exception handler.
Run-time system mulai mencari dari method di mana exception terjadi, dan melanjutkan melalui call stack dalam urutan terbalik di mana method dipanggil.
Jika menemukan penangan yang sesuai maka melewati exception yang terjadi padanya. Handler yang sesuai berarti jenis exception object yang dilempar cocok dengan jenis exception object yang dapat ditanganinya.
Jika run-time system mencari semua method pada call stack dan tidak dapat menemukan handler yang sesuai, maka run-time system akan menyerahkan exception object ke default exception handler, yang merupakan bagian dari run-time system. Handler ini mencetak informasi exception dalam format berikut dan menghentikan program secara tidak normal.

Exception in thread "xxx" Name of Exception : Description
... ...... ..  // Call Stack

Lihatlah diagram di bawah ini untuk memahami aliran call stack.

call stack

Ilustrasi:

// Java Program to Demonstrate How Exception Is Thrown
 
// Class
// ThrowsExecp
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Taking an empty string
        String str = null;
        // Getting length of a string
        System.out.println(str.length());
    }
}

Output:

Let us see an example that illustrates how a run-time system searches for appropriate exception handling code on the call stack.

Contoh:

// Java Program to Demonstrate Exception is Thrown
// How the runTime System Searches Call-Stack
// to Find Appropriate Exception Handler
 
// Class
// ExceptionThrown
class GFG {
 
    // Method 1
    // It throws the Exception(ArithmeticException).
    // Appropriate Exception handler is not found
    // within this method.
    static int divideByZero(int a, int b)
    {
 
        // this statement will cause ArithmeticException
        // (/by zero)
        int i = a / b;
 
        return i;
    }
 
    // The runTime System searches the appropriate
    // Exception handler in method also but couldn't have
    // found. So looking forward on the call stack
    static int computeDivision(int a, int b)
    {
 
        int res = 0;
 
        // Try block to check for exceptions
        try {
 
            res = divideByZero(a, b);
        }
 
        // Catch block to handle NumberFormatException
        // exception Doesn't matches with
        // ArithmeticException
        catch (NumberFormatException ex) {
            // Display message when exception occurs
            System.out.println(
                "NumberFormatException is occurred");
        }
        return res;
    }
 
    // Method 2
    // Found appropriate Exception handler.
    // i.e. matching catch block.
    public static void main(String args[])
    {
 
        int a = 1;
        int b = 0;
 
        // Try block to check for exceptions
        try {
            int i = computeDivision(a, b);
        }
 
        // Catch block to handle ArithmeticException
        // exceptions
        catch (ArithmeticException ex) {
 
            // getMessage() will print description
            // of exception(here / by zero)
            System.out.println(ex.getMessage());
        }
    }
}

Output

/ by zero

Referensi

https://www.geeksforgeeks.org/exceptions-in-java/