Mga Exception sa Java (Java Exception)

Sa pang-araw-araw na buhay, kung minsan ay may mga sitwasyon na lumitaw na hindi natin binalak. Halimbawa, gumising ka para sa trabaho sa umaga, maghanap ng charger para sa iyong telepono, ngunit wala. Pumunta ka sa banyo upang hugasan ang iyong mukha - ang tubig ay pinatay. Sumakay ako sa kotse at hindi ito umaandar. Ngunit ang isang tao ay madaling makayanan ang mga hindi inaasahang sitwasyon. Susubukan naming malaman kung paano makitungo sa kanila ang mga programa ng Java sa artikulong ito.

Ano ang mga pagbubukod ng java

Sa mundo ng programming, ang paglitaw ng mga error at hindi inaasahang sitwasyon sa panahon ng pagpapatupad ng programa ay tinatawag na eksepsiyon. Sa isang programa, maaaring mangyari ang mga pagbubukod bilang resulta ng mga maling aksyon ng user, kakulangan ng kinakailangang mapagkukunan sa disk, o pagkawala ng koneksyon sa server sa network. Ang mga pagbubukod sa panahon ng pagpapatupad ng programa ay maaari ding sanhi ng mga error sa programming o maling paggamit ng API. Hindi tulad ng ating mundo, dapat na malinaw na alam ng programa kung ano ang gagawin sa ganitong sitwasyon. Nagbibigay ang Java ng mekanismo ng pagbubukod para sa layuning ito.

Sa madaling sabi tungkol sa mga keyword subukan, hulihin, sa wakas, throws

Ang paghawak ng eksepsiyon sa Java ay batay sa paggamit ng mga sumusunod na keyword sa programa:

• subukan - tumutukoy sa isang bloke ng code kung saan maaaring mangyari ang isang pagbubukod;
• catch – tumutukoy sa block ng code kung saan pinangangasiwaan ang exception;
• sa wakas – tumutukoy sa isang bloke ng code na opsyonal, ngunit kung naroroon, ay isinasagawa pa rin, anuman ang mga resulta ng pagsubok na bloke.

Ang mga keyword na ito ay ginagamit upang lumikha ng mga espesyal na pagbuo ng pagpoproseso sa code ng programa: subukang{}huli, subukan{}huli{}sa wakas, subukan{}sa wakas{}.

• itapon - ginagamit upang itaas ang isang pagbubukod;
• throws - ginagamit sa mga lagda ng pamamaraan upang bigyan ng babala na ang pamamaraan ay maaaring maghagis ng eksepsiyon.

Isang halimbawa ng paggamit ng mga keyword sa isang Java program:

//method reads a string from the keyboard

public String input() throws MyException {//warn with 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
// if the compiler tells us that the readLine() method of the class
// BufferedReader may throw an I/O exception
    try {
        s = reader.readLine();
// in the catch block we enclose the code for handling the IOException exception
    } 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;
}

Bakit kailangan natin ng mekanismo ng pagbubukod?

Tingnan natin ang isang tunay na halimbawa sa mundo. Isipin na mayroong isang seksyon sa isang highway na may emergency na tulay na may limitadong kapasidad ng pagkarga. Kung ang isang sasakyan na may masa na lumampas sa kapasidad ng dala ng tulay ay tumawid dito, maaari itong bumagsak, at ang sitwasyon para sa driver ay maaaring maging, sa madaling sabi, pambihira. Upang maiwasang mangyari ito, ang serbisyo ng kalsada ay nag-i-install ng mga palatandaan ng babala sa kalsada nang maaga. Ang driver ng kotse, na tumitingin sa warning sign, ay ihahambing ang bigat ng kanyang sasakyan sa pinapayagang magmaneho sa tulay. Kung lumampas ito, liliko siya. Salamat sa mga aksyon ng serbisyo sa kalsada, ang mga driver ng trak, una, ay binigyan ng pagkakataon na baguhin ang kanilang ruta nang maaga, pangalawa, sila ay binigyan ng babala tungkol sa panganib sa pangunahing ruta, at, sa wakas, sila ay binigyan ng babala tungkol sa imposibilidad ng paggamit. ang tulay sa ilalim ng ilang mga kundisyon. Ang kakayahang pigilan at lutasin ang isang pagbubukod sa isang programa upang ito ay magpatuloy ay isa sa mga dahilan ng paggamit ng mga eksepsiyon sa Java. Ang mekanismo ng pagbubukod ay nagpapahintulot din sa iyo na protektahan ang code na iyong isinusulat (programming interface) mula sa maling paggamit ng user sa pamamagitan ng pagpapatunay (pagsuri) ng papasok na data. Ngayon maging pulis trapiko tayo sandali. Una, dapat alam mo ang mga lugar kung saan maaaring magkaroon ng gulo ang mga motorista. Pangalawa, kailangan mong maghanda at mag-install ng mga palatandaan ng babala. Panghuli, kailangan mong magbigay ng mga ruta ng detour kung sakaling magkaroon ng panganib sa pangunahing ruta. Sa Java, ang mekanismo ng pagbubukod ay gumagana sa katulad na paraan. Sa yugto ng pagbuo ng program, "pinoprotektahan" namin ang mga mapanganib na seksyon ng code mula sa mga pagbubukod gamit ang try{} block, nagbibigay ng "backup" na mga path gamit ang catch{} block, at sa panghuli{} block nagsusulat kami ng code na ipinapatupad sa programa para sa anumang resulta. Sa mga kaso kung saan hindi kami makakapagbigay ng "emerhensiyang ruta" o sadyang nais na ipaubaya sa gumagamit ang pagpili, dapat namin siyang bigyan ng babala man lang tungkol sa panganib. Bakit? Isipin na lang ang galit ng isang tsuper na makakarating sa isang tulay na pang-emerhensiya na hindi madadaanan nang hindi nakatagpo ng kahit isang babala sa daan! Sa programming, kapag isinusulat ang aming mga klase at pamamaraan, hindi namin palaging mahulaan ang konteksto ng kanilang paggamit ng ibang mga developer sa kanilang mga programa, kaya hindi namin mahulaan ang 100% tamang landas upang malutas ang sitwasyon ng pagbubukod. Kasabay nito, magandang kasanayan na bigyan ng babala ang mga gumagamit ng aming code tungkol sa posibilidad ng isang pagbubukod. Ang mekanismo ng pagbubukod ng Java ay nagbibigay-daan sa amin na gawin ito sa pamamagitan ng paggamit ng mga throws—na mahalagang deklarasyon ng pangkalahatang pag-uugali ng aming pamamaraan upang maghagis ng eksepsiyon, at sa gayon ay ipinauubaya sa gumagamit ng pamamaraan ang pagsulat ng code upang mahawakan ang eksepsiyon sa Java.

Babala ng "gulo"

Kapag wala kang planong humawak ng exception sa iyong pamamaraan, ngunit gusto mong bigyan ng babala ang mga user tungkol sa pamamaraan tungkol sa mga posibleng sitwasyon ng exception, gamitin ang throws na keyword. Ang keyword na ito sa isang lagda ng pamamaraan ay nangangahulugan na sa ilalim ng ilang mga kundisyon ang pamamaraan ay maaaring magtapon ng isang pagbubukod. Ang babalang ito ay bahagi ng interface ng pamamaraan at nagbibigay sa user ng karapatang i-customize ang pagpapatupad ng exception handler. Pagkatapos ng mga throws, ipinapahiwatig namin ang uri ng exception na itinapon. Ang mga ito ay karaniwang mga inapo ng klase ng Java Exception . Dahil ang Java ay isang object-oriented na wika, lahat ng exception sa Java ay mga object.

Java Exception Hierarchy

Kapag may naganap na error sa panahon ng pagpapatupad ng programa, ang JVM runtime ay lumilikha ng isang object ng kinakailangang uri mula sa Java exception hierarchy - ang hanay ng mga posibleng exception na minana mula sa isang karaniwang "ancestor" - ang Throwable class. Ang mga pambihirang sitwasyon na nangyayari sa isang programa ay maaaring nahahati sa dalawang grupo:

1. Mga sitwasyon kung saan ang pagpapanumbalik ng karagdagang normal na operasyon ng programa ay imposible
2. Posible ang pagbawi.

Kasama sa unang grupo ang mga sitwasyon kung kailan nangyari ang mga exception na minana mula sa Error class . Ang mga ito ay mga error na nangyayari sa panahon ng pagpapatupad ng programa bilang isang resulta ng isang pagkabigo ng JVM, overflow ng memorya, o pag-crash ng system. Karaniwang nagpapahiwatig ang mga ito ng mga seryosong problema na hindi maaayos gamit ang software. Ang ganitong uri ng exception sa Java ay inuri bilang walang check sa yugto ng compilation. Kasama rin sa pangkat na ito ang RuntimeException - mga exception, mga tagapagmana ng klase ng Exception , na nabuo ng JVM sa panahon ng pagpapatupad ng programa. Ang mga ito ay kadalasang sanhi ng mga error sa programming. Ang mga pagbubukod na ito ay hindi rin naka-check sa oras ng pag-compile, kaya ang pagsusulat ng code upang mahawakan ang mga ito ay hindi kinakailangan. Ang pangalawang grupo ay kinabibilangan ng mga pambihirang sitwasyon na nakikita sa yugto ng pagsulat ng programa, at kung saan ang processing code ay dapat isulat. Sinusuri ang mga naturang pagbubukod. Ang karamihan sa trabaho ng isang developer ng Java kapag nakikitungo sa mga pagbubukod ay ang paghawak sa mga ganitong sitwasyon.

Paglikha ng Exception

Sa panahon ng pagpapatupad ng programa, ang isang pagbubukod ay itinapon ng JVM o manu-manong gamit ang throw statement . Lumilikha ito ng exception object sa memorya at nakakaabala sa pagpapatupad ng pangunahing program code habang sinusubukan ng JVM exception handler na maghanap ng paraan upang mahawakan ang exception.

Exception Handling

Ang paggawa ng mga bloke ng code kung saan nagbibigay kami ng exception handling sa Java ay ginagawa sa program gamit ang try{}catch, try{}catch{}finally, try{}finally{} constructs. Kapag ang isang exception ay nakataas sa isang try block, ang exception handler ay hinahanap sa sumusunod na catch block. Kung ang catch ay naglalaman ng isang handler para sa ganitong uri ng exception, ang control ay pumasa dito. Kung hindi, ang JVM ay naghahanap ng isang tagapangasiwa para sa uri ng pagbubukod na iyon sa hanay ng mga tawag sa pamamaraan hanggang sa makahanap ng angkop na catch. Pagkatapos maisakatuparan ang catch block, ang kontrol ay ipapasa sa isang opsyonal na finally block . Kung hindi nahanap ang angkop na catch block, ihihinto ng JVM ang pagpapatupad ng programa at magpapakita ng stack ng mga method call - stack trace , na dati nang naisakatuparan ang panghuling block code, kung mayroon. Halimbawa ng exception handling:

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("-----------------");
        }

    }
    }

Ang mga resulta ng pangunahing pamamaraan :

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....
-----------------

Karaniwang ginagamit ang block finallyupang isara ang mga stream na binuksan sa try block o sa mga libreng mapagkukunan. Gayunpaman, kapag nagsusulat ng isang programa, hindi laging posible na subaybayan ang pagsasara ng lahat ng mga mapagkukunan. Upang gawing mas madali ang aming mga buhay, nag-alok sa amin ang mga developer ng Java ng isang konstruksyon try-with-resourcesna awtomatikong nagsasara ng mga mapagkukunang binuksan sa isang bloke ng pagsubok. Ang aming unang halimbawa ay maaaring muling isulat tulad nito 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;
}

Salamat sa mga kakayahan ng Java, simula sa bersyon 7, maaari rin nating pagsamahin ang pagkuha ng iba't ibang uri ng mga eksepsiyon sa isang bloke, na ginagawang mas compact at nababasa ang code. Halimbawa:

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;
}

Mga resulta

Ang paggamit ng mga eksepsiyon sa Java ay nagbibigay-daan sa amin upang mapataas ang fault tolerance ng programa sa pamamagitan ng paggamit ng mga "backup" na landas, paghiwalayin ang lohika ng pangunahing code mula sa exception handling code sa pamamagitan ng paggamit ng mga catch block, at nagbibigay din sa amin ng pagkakataong magtalaga exception handling sa user ng aming code gamit ang throws.