Pengendalian Pengecualian Java-javaTutorial-php.cn

Java Exception Handling

Asasnya

Memahami Pengecualian: Apa Yang Berlaku Apabila Masalah Berlaku?

Bayangkan anda sedang bermain permainan, dan tiba-tiba, watak anda jatuh ke dalam lubang. Apa yang anda akan lakukan? Anda mungkin akan memulakan semula permainan atau mencari jalan untuk mengelakkan pit lain kali. Dalam pengaturcaraan, sesuatu yang serupa boleh berlaku: kod anda mungkin jatuh ke dalam "lubang" yang dipanggil pengecualian. Apabila itu berlaku, program mungkin berhenti berfungsi atau melakukan sesuatu yang tidak dijangka.

Apakah Pengecualian Sebenarnya?

Pengecualian adalah seperti isyarat bahawa sesuatu telah berlaku semasa kod anda sedang dijalankan. Mungkin anda cuba membahagikan nombor dengan sifar (yang tidak dibenarkan), atau mungkin anda cuba membuka fail yang tidak wujud. Apabila masalah ini timbul, Java menaikkan bendera dan berkata, "Hei! Ada masalah di sini!"

Apa Berlaku Tanpa Pengendalian Pengecualian?

Jika kami tidak mengendalikan pengecualian, program mungkin ranap dan semua kemajuan hilang—sama seperti apabila anda tidak menyimpan permainan anda dan komputer tiba-tiba dimatikan.

Mari lihat contoh:

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;
        int result = number / 0; // This will cause an exception!
        System.out.println("Result: " + result); // This line will never be reached.
    }
}

Salin selepas log masuk

Apabila anda cuba menjalankan kod ini, ia akan berhenti dan mengeluh, sambil berkata, "Anda tidak boleh bahagi dengan sifar!"

Bagaimana Kita Boleh Mengelak Lubang?

Untuk mengelakkan masalah ini, Java memberi kita sesuatu yang dipanggil try and catch.

cuba Sekat: Di sinilah anda cuba melakukan sesuatu yang mungkin menyebabkan masalah.
tangkap Blok: Di sinilah anda mengetahui masalah jika ia berlaku, jadi program anda tidak ranap.

Mari Tulis Semula Contoh Kami:

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;

        try {
            int result = number / 0; // We know this might cause a problem.
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

Salin selepas log masuk

Inilah yang berlaku sekarang:

Blok cubaan cuba membahagi dengan sifar.
Apabila Java melihat masalah, ia melompat ke blok tangkapan dan berkata, "Op! Anda tidak boleh membahagi dengan sifar."

Menangkap Masalah Berbeza

Lagi Mengenai Menangkap Pengecualian

Sekarang anda tahu cara menangkap pengecualian, anda mungkin tertanya-tanya, "Bagaimana jika kod saya mungkin mempunyai pelbagai jenis masalah? Bagaimanakah cara untuk saya menangkap kesemuanya?"

Bayangkan anda cuba membuka peti harta karun dalam permainan. Kadang-kadang, kunci tidak muat (ini adalah satu masalah), dan pada masa lain, dada kosong (ini adalah masalah yang berbeza). Anda pasti ingin tahu apa yang salah, bukan?

Jenis Pengecualian Berbeza

Di Jawa, terdapat pelbagai jenis masalah, atau pengecualian. Contohnya:

ArithmeticException: Apabila anda cuba membuat matematik yang tidak masuk akal, seperti membahagi dengan sifar.
NullPointerException: Apabila anda cuba menggunakan sesuatu yang belum wujud (seperti cuba membuka peti harta karun yang tiada).
ArrayIndexOutOfBoundsException: Apabila anda cuba mencapai tatasusunan untuk sesuatu yang melebihi hadnya, seperti meminta kuki ke-11 dalam balang yang hanya mempunyai 10.

Menangkap Pelbagai Pengecualian

Mari lihat cara untuk menangkap pelbagai jenis masalah dalam kod anda:

public class MultipleExceptionsExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // This will cause an ArrayIndexOutOfBoundsException!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Oops! You tried to access an index that doesn’t exist.");
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

Salin selepas log masuk

Inilah yang berlaku:

Kod dalam blok cuba cuba melakukan sesuatu yang mungkin menyebabkan masalah.
Jika ia terserempak dengan ArrayIndexOutOfBoundsException, ia melompat ke blok tangkapan pertama.
Jika ia terserempak dengan ArithmeticException, ia melompat ke blok tangkapan kedua.

Bagaimana Jika Saya Ingin Menangkap Sebarang Masalah?

Kadangkala, anda mungkin tidak tahu apa yang boleh berlaku, tetapi anda masih mahu menghadapi sebarang masalah. Anda boleh menggunakan Pengecualian umum untuk menangkap apa-apa yang tidak kena:

public class GeneralExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an ArithmeticException!
        } catch (Exception e) {
            System.out.println("Oops! Something went wrong.");
        }
    }
}

Salin selepas log masuk

Dengan cara ini, jika berlaku masalah, blok tangkapan masih akan mengendalikannya dan program anda tidak akan ranap.

Membersihkan dan Membuat Pengecualian Tersuai

Blok akhirnya

Bayangkan anda sedang bermain permainan dan anda mencari harta karun, tetapi sama ada anda berjaya atau tidak, anda sentiasa mahu menutup peti harta karun apabila anda selesai. Di Jawa, blok akhirnya adalah seperti memastikan peti harta karun sentiasa ditutup, tidak kira apa yang berlaku.

Apakah Blok akhirnya?

Blok akhirnya ialah sekeping kod yang sentiasa dijalankan, sama ada pengecualian berlaku atau tidak. Ia digunakan untuk membersihkan, seperti menutup fail, menghentikan pemasa atau menyimpan peti harta karun.

Mari Lihat Contoh:

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception.
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        } finally {
            System.out.println("This will always run, no matter what.");
        }
    }
}

Salin selepas log masuk

Inilah yang berlaku:

The try block tries to do something risky.
The catch block catches the problem if it happens.
The finally block always runs, even if there’s no problem.

Making Your Own Custom Exceptions

Sometimes, the problems you face in your code are special. Maybe the game doesn’t just have treasure chests, but also magical doors that can sometimes be locked. You might want to create a special exception for when the door is locked.

Creating a Custom Exception

You can create your own exceptions by making a new class that extends Exception. Let’s create an exception called LockedDoorException:

class LockedDoorException extends Exception {
    public LockedDoorException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            openDoor(false);
        } catch (LockedDoorException e) {
            System.out.println(e.getMessage());
        }
    }

    private static void openDoor(boolean hasKey) throws LockedDoorException {
        if (!hasKey) {
            throw new LockedDoorException("The door is locked! You need a key.");
        }
        System.out.println("The door is open!");
    }
}

Salin selepas log masuk

Here’s how it works:

We create a new exception called LockedDoorException.
When we try to open the door without a key, we throw the LockedDoorException.
The catch block catches our custom exception and tells us what went wrong.

Summary

In this post, we’ve learned that:

Exceptions are problems that happen when your code is running.
try and catch blocks help us handle these problems, so our program doesn’t crash.
Different types of exceptions are like different kinds of problems.
We can catch multiple exceptions to handle specific problems.
We can also catch any exception using the general Exception type.
The finally block is used to clean up, and it always runs no matter what.
You can create custom exceptions to handle special problems in your code.