Pengecualian ing Jawa (Pengecualian Jawa)

Ing urip saben dina, kadhangkala ana kahanan sing ora direncanakake. Contone, sampeyan tangi kanggo kerja ing wayah esuk, golek pangisi daya kanggo telpon, nanging ora ana. Sampeyan menyang jedhing kanggo ngumbah pasuryan - banyu wis dipateni. Aku mlebu mobil lan ora bakal diwiwiti. Nanging wong iku bisa kanggo ngrampungake karo kahanan unforeseen kuwi cukup gampang. Kita bakal nyoba ngerteni kepiye program Java nangani ing artikel iki.

Apa sing dadi pengecualian java

Ing jagad pemrograman, kedadeyan kesalahan lan kahanan sing ora dikarepake sajrone eksekusi program diarani pengecualian. Ing program, pangecualian bisa kedadeyan amarga tumindak pangguna sing salah, kekurangan sumber daya sing dibutuhake ing disk, utawa ilang sambungan menyang server liwat jaringan. Pangecualian sajrone eksekusi program uga bisa disebabake kesalahan pemrograman utawa panggunaan API sing ora bener. Ora kaya jagad iki, program kasebut kudu ngerti kanthi jelas apa sing kudu ditindakake ing kahanan kaya ngono. Jawa menehi mekanisme pangecualian kanggo maksud iki.

Sedhela babagan tembung kunci nyoba, nyekel, pungkasane, mbuwang

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 kode sing opsional, nanging yen ana, wis kaleksanan tho, preduli saka asil pemblokiran nyoba.

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

• uncalan - digunakake kanggo mundhakaken pangecualian;
• uncalan - digunakake ing cara teken kanggo ngelingake yen cara bisa uncalan pangecualian.

Conto nggunakake tembung kunci ing program Jawa:

//method reads a string from the keyboard

public String input() throws MyException {//предупреждаем с помощью throws, 
// that the method can throw MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// in the try block we enclose the code in which an exception can occur, in this
// случае компилятор нам подсказывает, что метод readLine() класса 
// BufferedReader may throw an I/O exception
    try {
        s = reader.readLine();
// в блок  catch заключаем code по обработке исключения IOException  
    } catch (IOException e) {
        System.out.println(e.getMessage());
// close the read stream in the finally block
    } finally {
// when closing the stream, an exception is also possible, for example, if it was not opened, so we “wrap” the code in a try block
        try {
            reader.close();
// write exception handling when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// we decided that an empty string could disrupt the work of our program in the future, for example, on the result of this method, we need to call the substring(1,2) method, so we are forced to interrupt the program execution with the generation of our exception type MyException using throw
        throw new MyException("String can not be empty!");
    }
    return s;
}

Napa kita butuh mekanisme pangecualian?

Ayo katon ing conto donya nyata. Mbayangno yen ana bagean ing dalan gedhe kanthi jembatan darurat kanthi kapasitas muatan sing winates. Yen kendaraan kanthi massa ngluwihi kapasitas mbeta jembatan nyabrang, bisa ambruk, lan kahanan kanggo sopir bisa dadi, kanthi entheng, luar biasa. Kanggo nyegah kedadeyan kasebut, layanan dalan masang tandha peringatan ing dalan sadurunge. Sopir mobil, ndeleng tandha peringatan, bakal mbandhingake bobote mobil karo sing diijini nyopir ing jembatan. Yen ngluwihi, dheweke bakal nyimpang. Thanks kanggo tumindak layanan dalan, sopir truk, sepisanan, diwenehi kesempatan kanggo ngganti rute sadurunge, kaping pindho, dielingake babagan bebaya ing rute utama, lan, pungkasane, dielingake babagan impossibility nggunakake. jembatan ing kahanan tartamtu. Kemampuan kanggo nyegah lan ngatasi pengecualian ing program supaya bisa diterusake minangka salah sawijining alasan kanggo nggunakake pengecualian ing Jawa. Mekanisme pangecualian uga ngidini sampeyan nglindhungi kode sing sampeyan tulis (antarmuka pemrograman) saka penyalahgunaan dening pangguna kanthi validasi (mriksa) data sing mlebu. Saiki ayo dadi polisi lalu lintas sedhela. Kaping pisanan, sampeyan kudu ngerti papan sing bisa nemoni para motor. Kapindho, sampeyan kudu nyiyapake lan nginstal pratandha peringatan. Pungkasan, sampeyan kudu menehi rute detour yen ana bebaya ing rute utama. Ing Jawa, mekanisme pangecualian dianggo kanthi cara sing padha. Ing tataran pangembangan program, kita "nglindhungi" bagean kode sing mbebayani saka pangecualian nggunakake blok try{}, nyedhiyakake jalur "cadangan" nggunakake blok{} catch, lan ing blok{} pungkasane nulis kode sing dieksekusi ing program kanggo asil apa wae. Ing kasus nalika kita ora bisa nyedhiyani "rute darurat" utawa sengaja arep ninggalake pilihan kanggo pangguna, kita kudu paling ngelekake marang bebaya. Kenging punapa? Bayangna nesu saka sopir sing bakal tekan jembatan darurat sing ora bisa dilewati tanpa nemoni tandha peringatan ing dalan! Ing pemrograman, nalika nulis kelas lan metode, kita ora bisa tansah prédhiksi konteks panggunaane dening pangembang liyane ing program kasebut, mula kita ora bisa ngerteni dalan sing bener 100% kanggo ngatasi kahanan sing ora ana. Ing wektu sing padha, praktik sing apik kanggo ngelingake pangguna babagan kode babagan kemungkinan pengecualian. Mekanisme pangecualian Jawa ngidini kita nindakake iki kanthi nggunakake uncalan-utamane mratelakake prilaku umum metode kita kanggo mbuwang pangecualian, saéngga nyerahake pangguna metode kasebut kanggo nulis kode kanggo nangani pengecualian kasebut ing Jawa.

Peringatan "masalah"

Yen sampeyan ora duwe rencana kanggo nangani pangecualian ing metode sampeyan, nanging pengin ngelingake pangguna babagan cara kasebut babagan kahanan pangecualian, gunakake tembung kunci mbuwang. Tembung kunci iki ing teken cara tegese ing kahanan tartamtu cara bisa mbuwang pangecualian. Bebaya iki minangka bagean saka antarmuka metode lan menehi hak pangguna kanggo ngatur implementasine panangan pangecualian. Sawise mbuwang, kita nuduhake jinis pengecualian sing dibuwang. Iki biasane turunan saka kelas Java Exception . Amarga basa Jawa minangka basa sing berorientasi obyek, kabeh pangecualian ing Jawa minangka obyek.

Hierarki Pengecualian Jawa

Nalika ana kesalahan sajrone eksekusi program, runtime JVM nggawe obyek saka jinis sing dibutuhake saka hirarki pangecualian Java - set kemungkinan pengecualian sing diwarisake saka "leluhur" umum - kelas Throwable. Kahanan luar biasa sing kedadeyan ing program bisa dipérang dadi rong klompok:

1. Kahanan sing ora bisa dipulihake maneh operasi normal program
2. Recovery bisa.

Klompok pisanan kalebu kahanan nalika ana pangecualian sing diwarisake saka kelas Error . Iki minangka kesalahan sing kedadeyan sajrone eksekusi program minangka akibat saka kegagalan JVM, kebanjiran memori, utawa kacilakan sistem. Biasane nuduhake masalah serius sing ora bisa diatasi nggunakake piranti lunak. Pangecualian jinis iki ing Jawa diklasifikasikake minangka ora dicenthang ing tahap kompilasi. Klompok iki uga kalebu RuntimeException - pangecualian, pewaris kelas Exception , sing digawe dening JVM sajrone eksekusi program. Padha asring disebabake kesalahan pemrograman. Pangecualian iki uga ora dicenthang nalika kompilasi, mula nulis kode kanggo nangani ora perlu. Klompok kapindho kalebu kahanan luar biasa sing diramalake ing tahap nulis program, lan kode pangolahan kudu ditulis. Pengecualian kasebut dicenthang. Umume pakaryan pangembang Jawa nalika nangani pangecualian yaiku nangani kahanan kasebut.

Nggawe Pangecualian

Sajrone eksekusi program, pangecualian dibuwang dening JVM utawa kanthi manual nggunakake statement uncalan . Iki nggawe obyek pangecualian ing memori lan interrupts eksekusi kode program utama nalika JVM pangecualian handler nyoba golek cara kanggo nangani istiméwa.

Penanganan Pengecualian

Nggawe pamblokiran kode sing kita nyedhiyani pangecualian penanganan ing Jawa wis rampung ing program nggunakake coba{}catch, nyoba{}catch{}pungkasane, nyoba{}akhire{} konstruksi. Nalika pangecualian diunggahake ing blok coba, pawang pangecualian digoleki ing blok nyekel ing ngisor iki. Yen nyekel ngemot handler kanggo jinis iki istiméwa, kontrol liwat menyang. Yen ora, JVM katon kanggo handler kanggo jinis pangecualian ing chain saka cara telpon nganti nyekel cocok ketemu. Sawise pamblokiran nyekel dieksekusi, kontrol diterusake menyang blok pungkasan opsional . Yen pemblokiran nyekel cocok ora ketemu, JVM mungkasi eksekusi program lan nampilake tumpukan saka cara telpon - stack trace , wis sadurunge kaleksanan kode 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 method print: " + 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 was processed. Program continues");
            }
            finally {
                System.out.println("Inside bloсk finally");
            }
            System.out.println("Go program....");
            System.out.println("-----------------");
        }

    }
    }

Hasil saka metode utama :

Inside method print: first step
Inside bloсk finally
Go program....
-----------------
Exception: s is null!
Exception was processed. Program continues
Inside bloсk finally
Go program....
-----------------
Inside method print: second step
Inside bloсk finally
Go program....
-----------------

Blok kasebut finallybiasane digunakake kanggo nutup stream sing dibukak ing blok coba utawa mbebasake sumber daya. Nanging, nalika nulis program, ora tansah bisa nglacak penutupan kabeh sumber daya. Kanggo nggawe urip luwih gampang, pangembang Java nawakake kita konstruksi try-with-resourcessing otomatis nutup sumber daya sing dibukak ing blok coba. Conto pisanan kita bisa ditulis maneh kaya iki 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 ("String can not be empty!");
    }
    return s;
}

Thanks kanggo kemampuan Jawa, diwiwiti karo versi 7, kita uga bisa nggabungake macem-macem jinis pengecualian ing blok siji, nggawe kode luwih kompak lan bisa diwaca. Tuladhane:

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

Asil

Panggunaan pangecualian ing Jawa ngidini kita nambah toleransi fault saka program liwat nggunakake "serep" path, kanggo misahake logika kode utama saka kode pangecualian penanganan liwat nggunakake pamblokiran nyekel, lan uga menehi kita kesempatan kanggo utusan pangecualian penanganan kanggo pangguna kode kita nggunakake mbalang.