Menu
CoddyTech

Hierarki class Exception

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Java di Coddy. Pelajaran 59 dari 87.

Sistem penanganan exception Java dibangun berdasarkan hierarki class yang tersusun rapi dan berakar pada class Throwable. Memahami hierarki ini membantumu menangkap dan menangani exception dengan lebih efektif.

Di bagian paling atas terdapat Throwable, induk dari semua exception dan error. Throwable memiliki dua subclass langsung:

Throwable
├── Error          // Masalah serius (jangan tangkap ini)
└── Exception      // Masalah yang bisa ditangani
    └── RuntimeException  // Exception yang tidak diperiksa

error menunjukkan masalah serius yang sebaiknya tidak coba ditangani oleh aplikasi, seperti OutOfMemoryError atau StackOverflowError. Masalah ini menunjukkan adanya masalah mendasar pada JVM itu sendiri.

Exception adalah cabang yang paling sering kamu gunakan. Cabang ini terbagi menjadi dua kategori: exception yang diperiksa (subclass langsung dari Exception) dan exception yang tidak diperiksa (subclass dari RuntimeException).

// Class exception yang umum
Exception
├── IOException           // Masalah file atau jaringan
├── SQLException          // Masalah database
└── RuntimeException
    ├── NullPointerException
    ├── ArrayIndexOutOfBoundsException
    └── IllegalArgumentException

Karena exception adalah class, exception mengikuti aturan pewarisan. Saat kamu menangkap tipe exception induk, kamu juga menangkap semua turunannya:

try {
    // beberapa kode
} catch (Exception e) {
    // Menangkap SEMUA exception (biasanya terlalu luas)
}
try {
    // beberapa baris kode
} catch (RuntimeException e) {
    // Hanya menangkap pengecualian runtime dan subclass-nya
}

Hierarki ini memungkinkan kamu menentukan penanganan error secara spesifik atau umum sesuai kebutuhan, dan menjadi dasar untuk membuat exception kustommu sendiri.

challenge icon

Tantangan

Mudah

Mari buat penganalisis exception yang menunjukkan cara kerja hierarki exception Java dalam praktik! Kamu akan membuat sistem yang menangkap exception pada tingkat kekhususan yang berbeda dan melaporkan jenis yang tertangkap.

Kamu akan menyusun kodemu dalam tiga file:

  • ExceptionThrower.java: Buat class yang dapat memicu berbagai jenis exception berdasarkan input. Class-mu harus memiliki tiga fungsi static:

    triggerRuntime(String type) - Berdasarkan string jenisnya, lempar berbagai exception runtime:

    • Jika jenisnya "null", lempar NullPointerException dengan pesan "Null value encountered"
    • Jika jenisnya "index", lempar ArrayIndexOutOfBoundsException dengan pesan "Invalid index"
    • Jika jenisnya "argument", lempar IllegalArgumentException dengan pesan "Bad argument"

    triggerArithmetic() - Lempar ArithmeticException dengan pesan "Division error"

    triggerGeneric() - Lempar IllegalStateException dengan pesan "Generic runtime error" (hierarkinya adalah Exception > RuntimeException > IllegalStateException)

  • ExceptionAnalyzer.java: Buat class yang menangkap exception pada berbagai tingkat hierarki dan mengidentifikasi exception yang tertangkap. Sertakan fungsi static berikut:

    analyzeSpecific(String type) - Panggil ExceptionThrower.triggerRuntime(type) di dalam blok try. Gunakan blok catch terpisah untuk NullPointerException, ArrayIndexOutOfBoundsException, dan IllegalArgumentException. Untuk masing-masing, cetak: Caught specific: [exception class simple name] diikuti Message: [exception message]

    analyzeWithParent() - Panggil ExceptionThrower.triggerArithmetic() di dalam blok try. Tangkap exception tersebut menggunakan RuntimeException (jenis induknya). Cetak: Caught via parent: RuntimeException diikuti Actual type: [exception class simple name]

    analyzeWithGrandparent() - Panggil ExceptionThrower.triggerGeneric() di dalam blok try. Tangkap exception tersebut menggunakan Exception (tingkatnya lebih tinggi lagi dalam hierarki). Cetak: Caught via grandparent: Exception diikuti Actual type: [exception class simple name]

  • Main.java: Satukan penganalisis exception-mu! Kamu akan menerima satu input: string jenis exception (yaitu "null", "index", atau "argument").

    Pertama, cetak === Specific Catch === dan panggil analyzeSpecific dengan inputmu.

    Lalu cetak satu baris kosong, === Parent Catch ===, dan panggil analyzeWithParent.

    Terakhir, cetak satu baris kosong, === Grandparent Catch ===, dan panggil analyzeWithGrandparent.

Kamu akan menerima satu input: jenis exception yang akan dipicu ("null", "index", atau "argument").

Gunakan e.getClass().getSimpleName() untuk mendapatkan nama class exception dan e.getMessage() untuk mengambil pesannya. Tantangan ini menunjukkan bahwa menangkap jenis exception induk juga menangkap semua turunannya. Ini adalah konsep penting saat menentukan seberapa spesifik penanganan exception yang perlu kamu gunakan!

Coba sendiri

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String type = scanner.nextLine();
        
        // TODO: Cetak "=== Specific Catch ===" dan panggil ExceptionAnalyzer.analyzeSpecific(type)
        
        // TODO: Cetak baris kosong, lalu "=== Parent Catch ===", kemudian panggil ExceptionAnalyzer.analyzeWithParent()
        
        // TODO: Cetak baris kosong, lalu "=== Grandparent Catch ===", kemudian panggil ExceptionAnalyzer.analyzeWithGrandparent()
    }
}
quiz iconUji dirimu

Pelajaran ini berisi kuis singkat. Mulai pelajarannya untuk menjawab kuis dan melacak progresmu.

Semua pelajaran di Pemrograman Berorientasi Objek

Latihan sendiri: Compiler Java online