Menyelam dalam Pengecualian Java

Kelas Pengecualian Teras Java

hierarki kelas pengecualian: Boleh dibaling < Ralat < Pengecualian apabila Throwable ialah kelas super

Boleh dilempar

Kelas Throwable ialah kelas super bagi semua ralat dan pengecualian dalam bahasa Java. Hanya objek yang merupakan contoh kelas ini (atau salah satu subkelasnya) dilemparkan oleh Mesin Maya Java atau boleh dilemparkan oleh pernyataan lontaran Java. rujukan

Dalam amalan, Throwable biasanya tidak digunakan secara langsung oleh pembangun. Sebaliknya, ia berfungsi sebagai asas untuk dua subkelas langsungnya: Ralat dan Pengecualian.

try {
 // some process
} catch (Throwable t) {
    throw new Throwable(t);
}

ralat

Ralat ialah subkelas Boleh Lempar yang menunjukkan masalah serius yang tidak sepatutnya cuba ditangkap oleh aplikasi yang munasabah. Ralat biasanya mewakili keadaan tidak normal yang berlaku dalam rujukan JVM itu sendiri

Keadaan yang tidak normal bermakna masalah itu biasanya timbul daripada faktor di luar kawalan aplikasi dan secara amnya tidak dapat dipulihkan. Cth : OutOfMemoryError, StackOverflowError

Pengecualian

Pengecualian merujuk kepada peristiwa atau keadaan tidak dijangka yang berlaku semasa pelaksanaan program, dan kita harus mencuba menangkap. Dengan menangkap pengecualian, kita seharusnya dapat menangani situasi yang tidak dijangka dengan anggun, memastikan program tidak ranap.

int[] arr = {1, 2, 3};
try {
    System.out.println(arr[3]); // This will throw ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Unchecked Exception: " + e.getMessage());
}

 

Jenis Pengecualian

Terdapat 2 jenis pengecualian dalam java. rujukan

Pengecualian yang disemak

Pengecualian yang disemak adalah seperti situasi yang anda tahu mungkin salah, jadi anda perlu merancang untuknya. Mereka mesti sama ada ditangkap menggunakan blok cuba-tangkap atau diisytiharkan dalam tandatangan kaedah dengan klausa lontaran. Jika kaedah boleh membuang pengecualian yang diperiksa dan anda tidak mengendalikannya, atur cara tidak akan disusun.

// Checked exception
try {
    readFile("nonexistent.txt");
} catch (FileNotFoundException e) {
    System.out.println("Checked Exception: " + e.getMessage());
}

// Checked exception
public void getData() throws SQLException { // throw SQLException
    throw new SQLException("err");
}

Pengecualian tidak ditandai

Pengecualian tidak ditandai, aka. pengecualian runtime, adalah pengecualian yang pengkompil Java tidak memerlukan anda untuk mengendalikan. Mereka adalah subkelas RuntimeException. Tidak seperti pengecualian yang diperiksa, pengecualian ini tidak perlu ditangkap atau diisytiharkan dalam tandatangan kaedah. Ia biasanya menunjukkan ralat pengaturcaraan, seperti kecacatan logik, penggunaan API yang salah atau pelanggaran andaian dalam kod.

String text = null;
System.out.println(text.length()); // This will throw a NullPointerException

 

Jenis Biasa Pengecualian Java

NullPointerException: Berlaku apabila aplikasi cuba menggunakan rujukan objek yang belum dimulakan.

String text = null; // text is not initialized
try {
    System.out.println(text.length()); // Attempting to call length() on a null reference
} catch (NullPointerException e) {
    System.out.println("Caught a NullPointerException: " + e.getMessage());
}

ArrayIndexOutOfBoundsException: Dilemparkan apabila percubaan dibuat untuk mengakses tatasusunan dengan indeks yang tidak sah.

int[] numbers = {1, 2, 3};
try {
    int value = numbers[5]; // Attempting to access index 5, which is out of bounds
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught an ArrayIndexOutOfBoundsException: " + e.getMessage());
}

IllegalArgumentException: Dilemparkan apabila kaedah menerima hujah yang tidak sesuai.

public class IllegalArgumentExample {
    public static void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative"); // Illegal argument
        }
        System.out.println("Age set to: " + age);
    }

    public static void main(String[] args) {
        try {
            setAge(-5); // Passing a negative age, which is illegal
        } catch (IllegalArgumentException e) {
            System.out.println("Caught an IllegalArgumentException: " + e.getMessage());
        }
    }
}

 

Cara Mengendalikan Pengecualian

Cuba-Tangkap

Gunakan try-catch apabila anda ingin mengendalikan pengecualian khusus yang mungkin dilemparkan dalam blok kod

try {
    int result = 10 / 0; // This will throw ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Caught an ArithmeticException: " + e.getMessage());
}

Pelbagai Tangkapan

Gunakan berbilang tangkapan apabila anda ingin mengendalikan berbilang jenis pengecualian dengan cara yang sama

try {
    String str = null;
    System.out.println(str.length()); // This will throw NullPointerException
} catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught an exception: " + e.getMessage());
}

Cuba-Dengan-Sumber

Gunakan cuba-dengan-sumber apabila anda bekerja dengan sumber yang perlu ditutup selepas digunakan, seperti fail, soket atau sambungan pangkalan data.

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.out.println("Caught an IOException: " + e.getMessage());
}

Akhirnya

Gunakan blok akhirnya apabila anda perlu memastikan bahawa kod tertentu dilaksanakan tanpa mengira sama ada pengecualian telah dilemparkan atau tidak

try {
    file = new FileReader("file.txt");
} catch (IOException e) {
    System.out.println("Caught an IOException: " + e.getMessage());
} finally {
    if (file != null) {
        file.close(); // Ensure the file is closed
    }
}

 

Amalan Terbaik untuk Pengendalian Pengecualian

Jangan Abaikan Pengecualian: pengecualian harus dikendalikan dengan sewajarnya, bukan hanya ditangkap dan diabaikan.

try {
    file = new FileReader("file.txt");
} catch (IOException ignored) {
    // ignored
}

Gunakan Pengecualian Khusus: gunakan pengecualian khusus daripada menggunakan pengecualian generik.

try {
    // Code that may throw exceptions
    String text = null;
    text.length();
} catch (Exception e) {
    // Too broad; will catch all exceptions
    System.err.println("An error occurred: " + e.getMessage());
}

cara yang betul untuk mengendalikannya:

try {
    // Code that may throw exceptions
    String text = null;
    text.length();
} catch (NullPointerException e) {
    // Handle specific exception
    System.err.println("Null pointer exception: " + e.getMessage());
} catch (Exception e) {
    // Handle other exceptions
    System.err.println("An error occurred: " + e.getMessage());
}

Pengendalian Sumber Bersih: sentiasa tutup sumber untuk mengelakkan kebocoran memori

FileReader fileReader = null;
try {
    fileReader = new FileReader("file.txt");
    // Read from the file
} catch (IOException e) {
    System.err.println("File not found: " + e.getMessage());
} finally {
   fileReader.close(); // clouse resources
}

Pengecualian Tersuai: buat pengecualian tersuai apabila pengecualian standard tidak sesuai dengan keadaan ralat tertentu.

// Custom Exception
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// Usage
public class Example {
    public void performOperation() throws CustomException {
        // Some condition
        throw new CustomException("Custom error message");
    }

    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.performOperation();
        } catch (CustomException e) {
            System.err.println("Caught custom exception: " + e.getMessage());
        }
    }
}

Pengelogan: pengecualian log untuk penyahpepijatan dan penyelenggaraan.

public class Example {
    private static final Logger logger = Logger.getLogger(Example.class.getName());

    public void riskyMethod() {
        try {
            // Code that may throw an exception
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            // Log the exception
            logger.severe("An arithmetic error occurred: " + e.getMessage());
        }
    }
}

Elak Penggunaan Terlalu Banyak Pengecualian: Beri amaran terhadap penggunaan pengecualian untuk mengawal aliran; ia hanya boleh digunakan untuk mengendalikan situasi yang benar-benar luar biasa.

public class Example {
    public void process(int[] array) {
        try {
            // Using exceptions to control flow
            if (array.length < 5) {
                throw new ArrayIndexOutOfBoundsException("Array too small");
            }
            // Process array
        } catch (ArrayIndexOutOfBoundsException e) {
            // Handle exception
            System.out.println("Handled array size issue.");
        }
    }
}

cara yang betul untuk mengendalikannya:

public class Example {
    public void process(int[] array) {
        if (array.length >= 5) {
            // Process array
        } else {
            // Handle the condition without using exceptions
            System.out.println("Array is too small.");
        }
    }
}





 

sebarang maklum balas akan membantu :)


          

            
        
Atas ialah kandungan terperinci Menyelam dalam Pengecualian Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!