Pangecualian ing Jawa

Hello! Ing wulangan dina iki, kita bakal ngomong babagan Pengecualian Jawa. Urip saben dina kebak kahanan sing ora kita ngarepake. Contone, sampeyan tangi kerja ing wayah esuk lan golek pangisi daya telpon, nanging sampeyan ora bisa nemokake ing endi wae. Sampeyan menyang jedhing kanggo adus mung kanggo nemokake sing pipo beku. Sampeyan mlebu mobil, nanging ora bisa diwiwiti. Manungsa bisa ngatasi kahanan sing ora dikarepake kanthi gampang. Ing artikel iki, kita bakal nyoba ngerteni carane program Java ngatasi.

Apa pengecualian Jawa?

Ing jagad pemrograman, kesalahan lan kahanan sing ora dikarepake sajrone eksekusi program diarani pengecualian. Ing program, pangecualian bisa kedadeyan amarga tumindak pangguna sing ora bener, ruang disk sing ora cukup, utawa kelangan sambungan jaringan karo server. Pangecualian bisa uga amarga kesalahan pemrograman utawa panggunaan API sing salah. Ora kaya manungsa ing donya nyata, program kudu ngerti persis carane nangani kahanan kasebut. Kanggo iki, Jawa duwe mekanisme sing dikenal minangka penanganan pengecualian.

Sawetara tembung babagan tembung kunci

Penanganan pengecualian ing Jawa adhedhasar panggunaan tembung kunci ing ngisor iki ing program:

• nyoba - nemtokake blok kode ing ngendi pangecualian bisa kedadeyan;
• nyekel - nemtokake blok kode ing ngendi pangecualian ditangani;
• pungkasanipun - nemtokake pemblokiran opsional kode sing, yen ana, wis kaleksanan preduli saka asil pemblokiran nyoba.

Tembung kunci iki digunakake kanggo nggawe konstruksi khusus ing kode: coba{}cekel , coba{}cekel{}akhire , coba{}akhire{} .

• uncalan - digunakake kanggo mundhakaken pangecualian;
• mbalang - digunakake ing teken cara kanggo ngelekake sing cara bisa uncalan pangecualian.

Conto nggunakake tembung kunci ing program Java:

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

Napa kita butuh pangecualian?

Ayo katon ing conto saka donya nyata. Bayangake manawa bagean dalan gedhe duwe jembatan cilik kanthi kapasitas bobot sing winates. Yen mobil sing luwih abot tinimbang wates jembatan kasebut, bisa ambruk. Kahanan kanggo sopir bakal dadi, kanthi entheng, luar biasa. Kanggo ngindhari iki, dinas transportasi masang rambu-rambu peringatan ing dalan sadurunge ana sing salah. Ndelok tandha peringatan, sopir mbandhingake bobot kendaraane karo bobot maksimal kanggo jembatan. Yen kendaraan abot banget, sopir njupuk rute bypass. Dinas perhubungan, pisanan, ngidini sopir truk ngganti rute yen perlu, kapindho, ngelingake sopir babagan bebaya ing dalan gedhe, lan katelu, ngelingake driver yen jembatan kasebut ora kudu digunakake ing kahanan tartamtu. Kemampuan kanggo nyegah lan ngatasi kahanan sing luar biasa ing program, supaya bisa terus mlaku, minangka salah sawijining alesan kanggo nggunakake pengecualian ing Jawa. Mekanisme pangecualian uga ngidini sampeyan nglindhungi kode (API) saka panggunaan sing ora bener kanthi validasi (mriksa) input apa wae. Saiki bayangake yen sampeyan dadi departemen transportasi sedhela. Kaping pisanan, sampeyan kudu ngerti papan sing bisa diduga para pengendara. Kapindho, sampeyan kudu nggawe lan nginstal pratandha peringatan. Lan pungkasanipun, sampeyan kudu nyedhiyani detours yen ana masalah ing rute utama. Ing Jawa, mekanisme pangecualian dianggo kanthi cara sing padha. Sajrone pembangunan, kita nggunakake blok nyoba kanggo mbangun "pengecualian alangan" watara bagean mbebayani saka kode, kita nyedhiyani "rute serep" nggunakake nyekel {}pemblokiran, lan kita nulis kode sing kudu mbukak apa wae ing pungkasan{} pemblokiran. Yen kita ora bisa nyedhiyani "rute serep" utawa kita arep menehi pangguna hak kanggo milih, kita kudu paling ngelekake marang bebaya. Kenging punapa? Bayangna murka sopir sing, tanpa weruh tandha peringatan siji-sijine, tekan jembatan cilik sing ora bisa dilewati! Ing pemrograman, nalika nulis kelas lan metode, kita ora bisa ramalake carane bisa digunakake dening pangembang liyane. Akibaté, kita ora bisa prédhiksi 100% cara sing bener kanggo ngatasi kahanan sing luar biasa. Sing jarene, iku cara sing apik kanggo ngelingake wong liya babagan kemungkinan kahanan sing luar biasa. Mekanisme pangecualian Jawa ngidini kita nindakake iki kanthi mbuwangtembung kunci - ateges deklarasi yen prilaku umum metode kita kalebu mbuwang pengecualian. Dadi, sapa wae sing nggunakake metode kasebut ngerti dheweke kudu nulis kode kanggo nangani pengecualian.

Ngelingake wong liya babagan "masalah"

Yen sampeyan ora rencana nangani pangecualian ing cara sampeyan, nanging pengin ngelingake wong liya yen pangecualian bisa kedadeyan, gunakake tembung kunci throws . Tembung kunci iki ing tandha cara tegese, ing kahanan tartamtu, cara kasebut bisa uga ora ana pengecualian. Bebaya iki minangka bagean saka antarmuka metode lan ngidini pangguna ngetrapake logika penanganan pengecualian dhewe. Sawise mbuwang, kita nemtokake jinis pengecualian sing dibuwang. Iki biasane mudhun saka kelas Exception Jawa . Amarga basa Jawa minangka basa sing berorientasi obyek, kabeh pangecualian minangka obyek ing Jawa.

Hierarki pangecualian

Nalika ana kesalahan nalika program lagi mlaku, JVM nggawe obyek saka jinis cocok saka hirarki pangecualian Jawa - pesawat saka pangecualian sing bisa mudhun saka leluhur umum - kelas Throwable . Kita bisa dibagi kahanan runtime sing luar biasa dadi rong klompok:

1. Kahanan saka ngendi program ora bisa pulih lan terus operasi normal.
2. Kahanan ing ngendi pemulihan bisa.

Klompok pisanan kalebu kahanan sing kalebu pangecualian sing mudhun saka kelas Error . Iki minangka kesalahan sing kedadeyan amarga kesalahan JVM, overflow memori, utawa kegagalan sistem. Biasane nuduhake masalah serius sing ora bisa diatasi dening piranti lunak. Ing Jawa, kamungkinan pangecualian kasebut ora dicenthang dening kompiler, mula dikenal minangka pengecualian sing ora dicenthang. Klompok iki uga kalebu RuntimeExceptions, yaiku pangecualian sing mudhun saka Exceptionkelas lan kui dening JVM ing wektu roto. Padha asring disebabake kesalahan pemrograman. Pangecualian iki uga ora dicenthang (ora dicenthang) ing wektu kompilasi, dadi sampeyan ora perlu nulis kode kanggo nangani. Klompok kapindho kalebu kahanan sing luar biasa sing bisa diramal nalika sampeyan nulis program kasebut (lan sampeyan kudu nulis kode kanggo nangani). Pengecualian kasebut diarani pengecualian sing dicenthang. Nalika nerangake pangecualian, umume pakaryan pangembang Jawa nangani kahanan kaya ngono.

Nggawe pangecualian

Nalika program mlaku, pangecualian digawe dening JVM utawa kanthi manual nggunakake statement uncalan . Yen mengkono, obyek pangecualian digawe ing memori, aliran utama program diselani, lan JVM pangecualian handler nyoba kanggo nangani istiméwa.

Pangecualian penanganan

Ing Jawa, kita nggawe blok kode ing ngendi kita ngarep-arep perlu kanggo nangani pangecualian nggunakake coba{}catch , coba{}catch{}finally , lan coba{}finally{} constructions. Nalika pangecualian dibuwang ing pamblokiran nyoba , katon JVM pawang pangecualian cocok ing pemblokiran nyekel sabanjuré . Yen pamblokiran nyekel duwe handler istiméwa dibutuhake, kontrol liwat menyang. Yen ora, banjur JVM katon luwih mudhun chain pamblokiran nyekel nganti handler cocok ketemu. Sawise nglakokake blok nyekel , kontrol ditransfer menyang blok pungkasan opsional . Yen nyekel cocokpemblokiran ora ketemu, banjur JVM mungkasi program lan nampilake tilak tumpukan (tumpukan saiki saka cara nelpon), sawise pisanan nindakake pemblokiran pungkasan yen ana. Tuladha penanganan pengecualian:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s : list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

Mangkene asil saka metode utama :

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

Pungkasan biasane digunakake kanggo nutup aliran lan mbebasake sumber daya sing dibukak / diparengake ing blok coba . Nanging, nalika nulis program, ora mesthi bisa nglacak penutupan kabeh sumber daya. Kanggo nggawe urip luwih gampang, pangembang Jawa nawakake konstruksi coba-kanggo-sumber daya , sing kanthi otomatis nutup sumber daya sing dibukak ing blok coba . Conto pisanan kita bisa ditulis maneh karo try-with-resources :

public String input() throws MyException {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")) {
        throw new MyException ("The string cannot be empty!");
    }
    return s;
}

Thanks kanggo kabisan Jawa sing dikenalake ing versi 7, kita uga bisa nggabungake pangecualian sing heterogen dadi siji blok, nggawe kode luwih kompak lan bisa diwaca. Tuladha:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Garis ngisor

Nggunakake pangecualian ing Jawa ngidini sampeyan nggawe program luwih kuat kanthi nggawe "rute serep", gunakake pamblokiran nyekel kanggo misahake kode utama saka kode penanganan pangecualian, lan nggunakake uncalan kanggo mindhah tanggung jawab kanggo nangani pangecualian kanggo sapa wae sing nggunakake metode sampeyan .