Jenis Exception di Java | Parameter catch

Jenis Exceptions di Java

Java adalah bahasa pemrograman berorientasi objek. Ini memberikan dukungan untuk berbagai mekanisme seperti penanganan Exception . Fitur Java ini memungkinkan pengembang untuk mengelola kesalahan runtime yang disebabkan oleh Exception.

Exception adalah kesalahan atau bug atau peristiwa yang tidak diinginkan yang membatasi eksekusi normal suatu program biasanya penulisannya itu ada pada parameter catch. Setiap kali Exception terjadi, eksekusi program akan terganggu. Pesan kesalahan ditampilkan di layar.

Pada dasarnya pada exception itu ada Exception bawaan yang merupakan pengecualian/Exception yang tersedia di perpustakaan Java. Exception ini cocok untuk menjelaskan situasi kesalahan tertentu. Di bawah ini adalah daftar Exception bawaan yang penting di Java.

• Exception Aritmatika Ini dilemparkan ketika kondisi luar biasa telah terjadi dalam operasi aritmatika.
• ArrayIndexOutOfBoundException Dilemparkan untuk menunjukkan bahwa array telah diakses dengan indeks ilegal. Indeksnya negatif atau lebih besar dari atau sama dengan ukuran array.
• ClassNotFoundException Exception ini dimunculkan ketika kami mencoba mengakses kelas yang definisinya tidak ditemukan
• FileNotFoundException Exception ini dimunculkan ketika file tidak dapat diakses atau tidak terbuka.
• IOException Dilemparkan ketika operasi input-output gagal atau terganggu
• InterruptedException Ini dilemparkan ketika utas sedang menunggu, tidur, atau melakukan beberapa pemrosesan, dan itu terputus.
• NoSuchFieldException Ini dilemparkan ketika kelas tidak berisi bidang (atau variabel) yang ditentukan
• NoSuchMethodException Dilemparkan ketika mengakses metode yang tidak ditemukan.
• NullPointerException Exception ini muncul ketika merujuk ke anggota objek nol. Null tidak mewakili apa pun
• NumberFormatException Exception ini dimunculkan ketika metode tidak dapat mengubah string menjadi format numerik.
• RuntimeException Ini merupakan Exception yang terjadi selama runtime.
• StringIndexOutOfBoundsException Ini dilemparkan oleh metode kelas String untuk menunjukkan bahwa indeks baik negatif daripada ukuran string

Ada beberapa alasan di balik terjadinya Exception. Ini adalah beberapa kondisi di mana Exception terjadi:

• Setiap kali pengguna memberikan data yang tidak valid.
• File yang diminta untuk diakses tidak ada di sistem.
• Ketika Java Virtual Machine (JVM) kehabisan memori.
• Jaringan jatuh di tengah komunikasi.

Sekarang mari kita menjelajahi berbagai jenis Exception di Java.

Class induk dari semua Class Exception adalah Class java.lang.Exception . Berikut gambar mengilustrasikan berbagai jenis Exception Java.

Jika kita berbicara tentang Class Exception , itu adalah subclass dari Class Throwable bawaan . Ada subclass lain yang berasal dari Class Throwable yaitu Kesalahan seperti yang diilustrasikan dalam Gambar . Kesalahan dapat didefinisikan sebagai kondisi abnormal yang menunjukkan ada sesuatu yang salah dengan pelaksanaan program. Ini tidak ditangani oleh program Java.

Ada beberapa metode penting yang tersedia di Class Throwable yaitu sebagai berikut:

• public String getMessage () - Memberikan informasi tentang Exception yang telah terjadi melalui pesan, yang diinisialisasi dalam konstruktor Throwable .
• public Throwable getCause () - Menyediakan akar penyebab Exception sebagaimana diwakili oleh objek Throwable .
• public void printStackTrace () - Digunakan untuk menampilkan output toString () bersama dengan stack stack ke System.err (error output stream).
• public StackTraceElement [] getStackTrace () - Mengembalikan array dengan setiap elemen yang ada pada jejak stack. Elemen indeks 0 akan melambangkan bagian atas tumpukan panggilan, dan elemen terakhir array akan mengidentifikasi bagian bawah tumpukan panggilan.

Ada dua jenis Exception di Java sebagai berikut:

• Checked exception
• Unchecked exception

Checked exception

Exception yang diperiksa juga dikenal sebagai Exception waktu kompilasi karena Exception ini diperiksa oleh kompiler selama proses kompilasi untuk mengonfirmasi apakah Exception ditangani oleh programmer atau tidak. Jika tidak, maka sistem menampilkan kesalahan kompilasi. Misalnya, SQLException , IOException , InvocationTargetException, dan ClassNotFoundException .

Untuk mengilustrasikan konsep Exception yang diperiksa , mari kita pertimbangkan cuplikan kode berikut:

import java.io.*;
class demo1 {
    public static void main(String args[]) {
        FileInputStream input1 = null;

        /* FileInputStream(File filename) is a constructor that will throw
         *     FileNotFoundException (a checked exception) 
         */

        input1 = new FileInputStream("D:/file.txt");
        int m;

        // The read() of FileInputStream will also throw a checked exception
        while(( m = input1.read() ) != -1) {
            System.out.print((char)m);
        }

        // The close() will close the file input stream, and it will also throw a exception
        input1.close();
    }
}

Output

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
Unhandled exception type FileNotFoundException
Unhandled exception type IOException
Unhandled exception type IOException

Keyword throw

Ini ditampilkan dengan jelas di output bahwa program melempar Exception selama proses kompilasi. Ada dua metode untuk menyelesaikan masalah tersebut. Anda dapat mendeklarasikan Exception dengan bantuan kata kunci throw .

import java.io.*;
class demo1 {
    public static void main(String args[]) throws IOException {
        FileInputStream input1 = null;
        input1 = new FileInputStream("D:/file.txt");

        int m;
        while ((m = input1.read()) != -1) {
            System.out.print((char)m);
        }

        input1.close();
    }
}

Output:
File akan ditampilkan di layar.

blok try-catch

Terlepas dari metode yang disebutkan di atas, ada cara lain untuk menyelesaikan Exception. Anda dapat mengelolanya dengan bantuan blok try-catch .

import java.io.*;
class demo1 {
    public static void main(String args[]) {
        FileInputStream input1 = null;
        try {
            input1 = new FileInputStream("D:/file.txt");
        } catch(FileNotFoundException input2) {
            system.out.println("The file does not " + "exist at the location");
        }

        int m;
        try {
            while((m = input1.read()) != -1) {
                System.out.print((char)m);
            }

            input1.close();
        } catch(IOException input3) {
            system.out.println("I/O error occurred: "+ input3);
        }
    }
}

SQLException

Jenis Exception ini terjadi saat menjalankan kueri pada database yang terkait dengan sintaks SQL. Misalnya, perhatikan cuplikan kode berikut:

public void setClientInfo(String sname, String svalue) throws SQLClientInfoException {
    try {
        checkClosed();
        ((java.sql.Connection) this.mc).setClientInfo(sname, svalue);
    } catch (SQLException sqlEx) {
        try {
            checkAndFireConnectionError(sqlEx);
        } catch (SQLException sqlEx2) {
            SQLClientInfoException client_Ex = new SQLClientInfoException();
            client_Ex.initCause(sqlEx2);
            throw client_Ex;
        }
    }
}

Output: 
Kode ini akan menghasilkan SQLException.

IOException

Jenis Exception ini terjadi saat menggunakan operasi aliran I / O file. Misalnya, perhatikan cuplikan kode berikut:

import java.io.*;
public class sample_IOException {
    private static String filepath = "D:\User\guest\Desktop\File2.txt";

    public static void main(String[] args) {
        BufferedReader br1 = null;
        String curline;

        try {
            br1 = new BufferedReader(new FileReader(filepath));

            while ((curline = br1.readLine()) != null) {
                System.out.println(curline);
            }
        } catch (IOException e) {
            System.err.println("IOException found :" + e.getMessage());
        } finally {
            try {
                if (br1 != null)
                    br1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Output: Kode ini akan menghasilkan IOException.

ClassNotFoundException

Jenis Exception ini dilemparkan ketika JVM tidak dapat menemukan Class yang diperlukan. Mungkin karena kesalahan baris perintah , masalah classpath , atau file .class yang hilang . Misalnya, perhatikan cuplikan kode berikut:

public class sample_ClassNotFoundException {
    private static final String CLASS_TO_LOAD = "main.java.Utils";

    public static void main(String[] args) {
        try {
            Class loadedClass = Class.forName(CLASS_TO_LOAD);
            System.out.println("Class " + loadedClass + " found!");
        } catch (ClassNotFoundException ex) {
            System.err.println("ClassNotFoundException was found: " + ex.getMessage());
            ex.printStackTrace();
        }
    }
}

Output: Kode ini akan menghasilkan ClassNotFoundException.

InvocationTargetException

Jenis Exception ini membungkus Exception yang dilemparkan dengan metode yang dipanggil atau konstruktor. Exception yang dilemparkan dapat diakses dengan bantuan metode getTargetException . Misalnya, perhatikan cuplikan kode berikut:

package main.samplejava;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Example {
    @SuppressWarnings("unused")
    private int test_sample(String s1) {
        if (s1.length() == 0)
            throw new IllegalArgumentException("The string should have at least one character!");
        System.out.println("Inside test_sample: argument's value equals to: "" + s1 + """);
        return 0;
    }

    public static void main(String... args) {
        try {
            Class c1 = Class.forName("main.samplejava. Example");
            Object t1 = c1.newInstance();
            Method[] declared_Methods = c1.getDeclaredMethods();
            for (Method method : declared_Methods) {
                String methodName = method.getName();
                if (methodName.contains("main"))
                    continue;

                System.out.format("Invoking %s()%n", methodName);

                try {
                    method.setAccessible(true);
                    Object returnValue = method.invoke(t1, "");
                    System.out.format("%s() returned: %d%n", methodName, returnValue);
                } catch (InvocationTargetException ex) {
                    System.err.println("An InvocationTargetException was caught!");
                    Throwable cause = ex.getCause();
                    System.out.format("Invocation of %s failed because of: %s%n",
                        methodName, cause.getMessage());
                }
            }
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
            System.err.println("The following exception was thrown:");
            ex.printStackTrace();
        }
    }
}

Output

Invoking testMethod()
An InvocationTargetException was caught!
Invocation of testMethod failed because of: The string must contain at least one character!

Unchecked exception

Exception yang tidak dicentang adalah Exception yang terjadi selama pelaksanaan program. Karenanya mereka juga disebut sebagai Exception Runtime . Exception ini umumnya diabaikan selama proses kompilasi. Mereka tidak diperiksa saat menyusun program. Misalnya, pemrograman bug seperti kesalahan logis, dan menggunakan API yang salah.

Untuk mengilustrasikan konsep Exception yang tidak dicentang , mari kita pertimbangkan cuplikan kode berikut:

import java.util.Scanner;
public class Sample_RunTimeException {
    public static void main(String[] args) {
        // Reading user input
        Scanner input_dev = new Scanner(System.in);
        System.out.print("Enter your age in Numbers: ");
        int age1 = input_dev.nextInt();
        if (age1>20) {
            System.out.println("You can view the page");
        } else {
            System.out.println("You cannot view the page");
        }
    }
}

Output1

Enter your age in Numbers: 21
You can view the page

Output2

Enter your age in Numbers: Twelve
Exception in thread “main” java.util.InputMismatchException
at java.util.Scanner.throwFor (Unknown Source)
at java.util.Scanner.next (Unknown Source)
at java.util.Scanner.nextInt (Unknown Source)
at java.util.Scanner.nextInt (Unknown Source)
at exceptiondemo.sample_runtimedemo.main(Sample_RunTimeExceptionDemo.java:11)

Sekarang, mari kita belajar tentang Exception lain yang tidak dicentang. Beberapa dari mereka adalah:

NullPointerException

Jenis Exception ini terjadi ketika Anda mencoba mengakses objek dengan bantuan variabel referensi yang nilainya saat ini nol atau kosong. Misalnya, perhatikan cuplikan kode berikut:

class SampleNullPointer {
    public static void main(String args[]) {
        try {
            String a1 = null; // null value
            System.out.println(a1.charAt(0));
        } catch(NullPointerException e) {
            System.out.println("NullPointerException is found in the program.");
        }
    }
}

Output:
NullPointerException ditemukan dalam program.

ArrayIndexOutofBound

Jenis Exception ini terjadi ketika Anda mencoba mengakses array dengan nilai indeks yang tidak valid. Nilai yang Anda berikan adalah negatif atau melampaui panjang array.

Misalnya, perhatikan cuplikan kode berikut:

class sample_ArrayIndexOutOfBound {
    public static void main(String args[]) {
        try {
            int b[] = new int[6];
            b[8] = 2; // we are trying to access 9th element in an array of size 7
        } catch(ArrayIndexOutOfBoundsException e) {
            System.out.println ("The array index is out of bound");
        }
    }
}

Output: 
Indeks array tidak terikat

IllegalArgumentException

Jenis Exception ini terjadi setiap kali argumen yang tidak pantas atau tidak benar diteruskan ke suatu metode. Misalnya, jika suatu metode didefinisikan dengan string yang tidak kosong sebagai parameter. Tetapi Anda memberikan string input nol. Kemudian, IllegalArgumentException dilemparkan untuk menunjukkan kepada pengguna bahwa Anda tidak dapat melewatkan string input nol ke metode.

Pertimbangkan cuplikan kode berikut untuk menunjukkan jenis Exception ini:

import java.io.File;
public class Sample_IllegalArgumentException {
    public static String createRelativePath(String par, String f_name) {
        if (par == null)
            throw new IllegalArgumentException("You cannot provide null parent path!");

        if (f_name == null)
            throw new IllegalArgumentException("Please enter the complete filename!");
        
        return par + File.separator + f_name;
    }

    public static void main(String[] args) {
        // This command will be successfully executed.
        system.out.println(IllegalArgumentExceptionExample.createRelativePath("dir1", "file1"));
        system.out.println();

        // This command will throw an IllegalArgumentException.
        System.out.println(IllegalArgumentExceptionExample.createRelativePath(null, "file1"));
    }
}

Output: This code will generate an IllegalArgumentException.

IllegalStateException

Jenis Exception ini terjadi ketika keadaan lingkungan tidak cocok dengan operasi yang sedang dijalankan. Misalnya, perhatikan cuplikan kode berikut, yang menunjukkan jenis Exception ini:

public void pub() throws IllegalStateException {
    Date pub_at = getPub_at();

    if (pub_at == null) {
        setPub_at(new Date());
        Logging.log(String.format("Published '%s' by %s.", getTitle(), getAuthor()));
    } else {
        throw new IllegalStateException(
        String.format("Cannot publish '%s' by %s (already published on %s).",
            getTitle(), getAuthor(), pub_at));
    }
}

Output 
Kode ini akan menghasilkan IllegalStateException.

Jika tanggal publikasi sudah ada dalam sistem, maka itu akan menghasilkan IllegalStateException yang menunjukkan bahwa buku tidak dapat diterbitkan lagi.

NumberFormatException

Jenis Exception ini terjadi ketika Anda meneruskan string ke metode yang tidak dapat dikonversi ke angka. Misalnya, perhatikan cuplikan kode berikut:

class Sample_NumberFormat {
    public static void main(String args[]) {
        try {
            // "Test" is not a number
            int n = Integer.parseInt ("Test") ;
            System.out.println(n);
        } catch(NumberFormatException e) {
            System.out.println("Number format exception");
        }
    }
}

Output 
Kode ini akan menghasilkan NumberFormatException.

ArithmeticException

Jenis Exception ini terjadi ketika Anda melakukan operasi aritmatika yang salah. Misalnya, jika Anda membagi angka dengan nol, itu akan menampilkan Exception seperti itu. Mari kita perhatikan cuplikan kode berikut:

class Sample_ArithmeticException {
    public static void main(String args[]) {
        try {
            int p = 30, q = 0;
            int r = p/q;  // It cannot be divided by zero
            System.out.println ("Result = " + r);
        } catch(ArithmeticException e) {
            System.out.println ("Number cannot be divided by 0");
        }
    }
}

POSTINGAN ARTIKELTA

Output
Kode ini akan menghasilkan ArithmeticException.

• Twitter
• Facebook
• Google
• Tumblr
• Pinterest

Taufiq Wahid