Java throw Exception

Ke mana sahaja kita pergi, peristiwa yang tidak dapat diramalkan menanti kita. Gempa bumi, tindakan tidak rasional manusia, meteorit... atau sesuatu yang lebih mudah — mentol lampu terbakar, kad bank demagnet, tolok petrol pecah. Kita tidak boleh melumpuhkan peristiwa yang tidak dapat diramalkan, tetapi kita sekurang-kurangnya boleh bersedia sebahagiannya untuknya. Maksudnya, kita mesti menyediakan mekanisme tertentu untuk menanganinya. Dalam dunia pengaturcaraan, khususnya dalam bahasa Java, peristiwa yang menghalang program daripada berfungsi secara normal dipanggil pengecualian, dan mekanisme untuk mencegah ranap program dipanggil pengendalian pengecualian. Jadi, apabila peristiwa yang tidak dijangka berlaku dalam program, seperti pembahagian dengan sifar, ia harus "membuang" pengecualian. Pengendalian pengecualian ialah aspek penting pengaturcaraan Java yang membantu pembangun mengurus ralat dan pengecualian yang mungkin berlaku semasa pelaksanaan program. Dalam artikel ini, kami akan menumpukan pada salah satu konsep asas pengendalian pengecualian: kata kunci lempar Java dan cara menggunakannya untuk membuang pengecualian.

Apakah Pengecualian di Jawa?

Pengecualian ialah peristiwa yang berlaku semasa pelaksanaan program yang mengganggu aliran biasa arahan program. Apabila pengecualian berlaku, pelaksanaan program dihentikan, dan mesej ralat dipaparkan pada konsol. Di Jawa, terdapat dua jenis pengecualian: ditanda dan tidak ditanda. Pengecualian yang diperiksa disemak pada masa penyusunan, dan pengkompil memastikan bahawa ia ditangkap atau diisytiharkan oleh kaedah panggilan. Sebaliknya, pengecualian yang tidak disemak tidak disemak pada masa penyusunan, dan ia boleh ditangkap atau dibiarkan tidak ditangkap. Berikut ialah contoh kod di mana ralat mungkin berlaku, tetapi pengkompil melangkaunya.

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Berikut adalah output program: Program keluar dengan betul, tetapi menghasilkan keputusan yang salah. Dalam kes pertama, kerana hujah fungsi adalah negatif, dan faktorial tidak berfungsi untuk nombor negatif. Dalam kes kedua, keputusannya salah, kerana bilangannya terlalu besar untuk mengira faktorialnya dalam julat jenis panjang. Berikut adalah satu lagi contoh. Mari kita tulis program di mana kita akan membahagikan satu nombor dengan yang lain.

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

Dalam contoh ini, ArithmeticException akan dilemparkan kerana pembolehubah b ialah sifar. Walau bagaimanapun, ralat ini tidak dikendalikan, jadi program keluar dengan status yang salah.

Bagaimana untuk membuang pengecualian di Jawa

Di Jawa, pengecualian juga merupakan objek, jadi pengecualian dilemparkan sama seperti objek Pengecualian baharu yang dicipta. Pengecualian dilemparkan dalam atur cara menggunakan pernyataan lontaran. Biasanya, kedua-dua operasi ini (penciptaan objek dan melontar pengecualian) digabungkan menjadi satu:

throw new Exception("error…");

Kata kunci lontaran dalam Java digunakan untuk membuang pengecualian daripada kaedah atau blok kod apabila ralat atau keadaan luar biasa berlaku yang tidak dapat dikendalikan oleh program semasa masa jalan . Aliran program diubah hala ke blok tangkapan terdekat. Blok ini boleh mengurus pengecualian.

Contoh penggunaan kata kunci 'buang'

Untuk menggambarkan kefungsian kata kunci lontaran dalam Java, mari kita ambil contoh. Mari kita tulis kaedah untuk mengira faktorial nombor. Jika nombor negatif, ia tidak boleh dikira, jadi pengecualian mesti dibuang. Begitu juga, jika bilangannya terlalu besar, hasil faktorial akan melebihi saiz maksimum jenis panjang, dan satu lagi pengecualian akan dilemparkan. Di sini kita mempunyai pelaksanaan kaedah:

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

Dalam contoh ini, jika nilai nombor adalah negatif, kata kunci lontaran digunakan untuk membuang tika kelas IllegalArgumentException . Jika anda menjalankan program, mesej "Argumen tidak sah" akan dipaparkan pada konsol. Pelaksanaan program akan dihentikan.

Tiada lagi ralat: menangkap contoh pengecualian

Sekarang mari kita ingat contoh kedua, dengan pembahagian dengan sifar, dan laksanakannya dengan pengendalian pengecualian.

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Dalam contoh ini, kami telah menambah binaan cuba-tangkap untuk mengendalikan pengecualian bahagi-dengan-sifar. Secara ringkasnya, try-catch-finally ialah binaan bahasa pengaturcaraan Java yang membolehkan anda mengendalikan pengecualian dan melaksanakan kod tanpa mengira sama ada pengecualian berlaku atau tidak. try-catch-finally terdiri daripada tiga blok:

• Blok percubaan . Kod yang berpotensi berbahaya sedang dilaksanakan di sini. Itu adalah kod yang boleh membuang pengecualian. Jika pengecualian berlaku dalam blok cuba , pelaksanaan kod dalam blok itu dibatalkan dan kawalan dipindahkan ke blok tangkapan.
• Blok tangkapan . Di sini pengecualian yang dilemparkan dikendalikan. Dalam blok tangkapan , anda boleh menentukan pengecualian yang mana untuk ditangkap dan logik yang perlu dilaksanakan apabila ia ditangkap.
Blok akhirnya . Yang ini dilaksanakan tanpa mengira sama ada pengecualian berlaku atau tidak. Blok akhirnya digunakan, sebagai contoh, untuk melepaskan sumber (seperti menutup fail atau soket) yang diperuntukkan dalam blok percubaan. Anda boleh meninggalkan blok ini.

Konstruk try -catch-finally membolehkan kawalan yang lebih tepat ke atas pelaksanaan program sekiranya berlaku situasi luar biasa dan membantu mencegah penamatan program yang tidak dijangka sekiranya berlaku ralat. Sekarang, mari kita kembali kepada contoh kita. Jika pembahagian dengan sifar berlaku semasa kaedah bahagi, ArithmeticException akan dilemparkan, yang ditangkap oleh blok tangkapan. Dalam blok tangkapan , kami hanya mencetak mesej ralat ke konsol. Jika tiada pengecualian berlaku, program akan meneruskan pelaksanaannya.

melontar kata kunci

Kata kunci lontaran digunakan dalam tandatangan kaedah . Jika ya, ini bermakna pengecualian sedang dilemparkan dalam kaedah. Ini boleh menyebarkan pengecualian ke atas timbunan panggilan dan menunjukkan bahawa pengecualian tidak perlu dikendalikan dalam kaedah semasa. Di Java, "lemparan" juga boleh digunakan untuk merujuk kepada pengecualian tersuai yang ditakrifkan dalam program. Sebagai contoh, kaedah boleh melakukan pembahagian dua nombor tetapi membuang IllegalArgumentException jika hujah kedua adalah sifar:

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Kaedah ini menggunakan kata kunci lontaran untuk menunjukkan bahawa IllegalArgumentException boleh dilemparkan jika argumen kedua adalah batal. Jika pengecualian sedemikian berlaku semasa melaksanakan kaedah, ia akan dihantar kepada kaedah panggilan untuk pemprosesan. Contoh panggilan kaedah:

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

Dalam contoh ini, kaedah divide() dipanggil dengan hujah 10 dan 0, yang akan membuang IllegalArgumentException kerana pembahagian dengan sifar adalah mustahil. Pengecualian akan ditangkap oleh blok cuba-tangkap , dan mesej ralat akan dipaparkan. Program ini akan menghasilkan nilai sifar kerana pengecualian menamatkan pelaksanaan kaedah divid() .