Ipinapakilala ang mga pagbubukod

"Kumusta, Amigo. Magkakaroon tayo ng isang napaka-kagiliw-giliw na aralin ngayon. Sasabihin ko sa iyo ang tungkol sa mga pagbubukod. Ang mga pagbubukod ay isang espesyal na mekanismo na nagbibigay-daan sa amin upang mahawakan ang mga error sa programa. Narito ang ilang mga halimbawa ng mga error na maaaring mangyari sa isang programa:

1. Maaaring subukan ng program na magsulat ng isang file kapag ang hard drive ay ganap na puno.

2. Maaaring subukan ng program na tumawag ng isang paraan sa isang variable na nag-iimbak ng isang null reference.

3. Maaaring subukan ng program na hatiin ang isang numero sa 0."

Ang lahat ng mga pagkilos na ito ay nagreresulta sa mga pagkakamali. Karaniwan, ang resulta ay agad na nagtatapos ang programa, dahil walang saysay na ipagpatuloy ang pagpapatupad ng code sa kasong ito.

"Bakit?"

"May katuturan ba ang patuloy na pag-ikot ng gulong kung ang kotse ay nawala sa kalsada at nahulog mula sa isang bangin?"

"Kung gayon, dapat bang huminto ang programa?"

"Oo. At least, ganito ang nangyari dati. Any error cause the program to terminate."

"Iyan ay isang napaka-matalinong diskarte."

"Ngunit hindi ba mas mabuting subukan at ipagpatuloy ang pagpapatakbo ng programa?"

"Oo. Ipagpalagay na nag-type ka ng isang malaking halaga ng teksto sa Word at na-save ito. Paano kung nabigo ang operasyon ng pag-save, ngunit ang programa ay humantong sa iyo na maniwala na ang lahat ay maayos? At magpatuloy ka sa pagta-type. Iyan ay magiging hangal, hindi ba ito?"

"Oo."

"Pagkatapos ay nakaisip ang mga programmer ng isang kawili-wiling solusyon: ibabalik ng bawat function ang katayuan ng trabaho nito. Ang ibig sabihin ng 0 ay gumana ito gaya ng inaasahan. Anumang ibang value ay nangangahulugan na may naganap na error, at ang return value ay isang error code."

"Gayunpaman, ang diskarte na iyon ay mayroon ding mga pagkukulang. Pagkatapos ng bawat (!) function na tawag, kailangan mong suriin ang return code (numero). Una sa lahat, ito ay hindi maginhawa: ang error-handling code ay bihirang isagawa ngunit kailangang isama kahit saan. Pangalawa, ang mga function ay madalas na nagbabalik ng iba't ibang mga halaga - ano ang dapat mong gawin sa kanila?"

"Tama. Naisip ko din yun."

"Pagkatapos, dumating ang isang magandang kinabukasan sa anyo ng mga pagbubukod at mekanismo sa paghawak ng error. Narito kung paano ito gumagana:

1. Kapag may naganap na error, ang Java Machine ay lumilikha ng isang espesyal na bagay - isang pagbubukod - kung saan sini-save nito ang lahat ng impormasyon ng error. Mayroong iba't ibang mga pagbubukod para sa iba't ibang mga error.

2. Ang isang pagbubukod ay nagiging sanhi ng programa upang agad na lumabas sa kasalukuyang function, at ang susunod na function, at iba pa - hanggang sa lumabas ito sa pangunahing paraan. Pagkatapos ay magtatapos ang programa. Maaaring sabihin din ng mga programmer na ang Java Machine ay 'nag-unwind ng call stack'."

"Ngunit sinabi mo na ang programa ay hindi palaging natatapos."

"Oo, dahil may paraan para makahuli ng exception. Maaari tayong magsulat ng espesyal na code sa tamang lugar para makuha ang mga exception na pinapahalagahan natin at gumawa ng isang bagay sa kanila. Mahalagang bagay ito."

"Upang matulungan kaming gawin ito, mayroong isang espesyal na try-catch construct. Narito kung paano ito gumagana:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (Exception e)
        {
           System.out.println("Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

Program starts
Before method1 calling
Exception has been caught
Program is still running

"Ngunit bakit hindi ipapakita sa screen ang 'After calling method1. This will never be shown'?"

"Natutuwa akong nagtanong ka. Sa linya 25, hinahati namin sa 0, na humahantong sa isang error - isang exception. Lumilikha ang Java Machine ng ArithmeticException object na may impormasyon tungkol sa error. Ang object ay exception."

"Ang pagbubukod ay nangyayari sa loob ng method1pamamaraan. Nagiging sanhi ito ng paraan upang wakasan kaagad. Ito ay magiging sanhi ng pangunahing paraan upang wakasan kung hindi para sa try-catch block."

"Kung may maganap na exception sa loob ng try block, ito ay mahuhuli sa catch block. Ang natitira sa code sa try block ay hindi isasagawa. Sa halip, ang catch block ay magsisimulang isagawa. "

"Hindi ko gets."

"Sa madaling salita, ang code ay gumagana tulad nito:

1. Kung ang isang exception ay nangyari sa loob ng isang try block, ang code ay titigil sa pag-execute kung saan ang exception ay naganap at ang catch block ay nagsimulang i-execute.

2. Kung walang pagbubukod na nangyari, pagkatapos ay ang try block ay isasagawa hanggang sa dulo , at ang catch block ay hindi naisakatuparan. "

"Huh?"

"Isipin na pagkatapos ng bawat tawag sa pamamaraan ay sinusuri namin kung ang pamamaraan ay bumalik nang normal o biglang tinapos bilang isang resulta ng isang pagbubukod. Kung mayroong isang pagbubukod, pagkatapos ay lilipat kami upang isagawa ang catch block (kung mayroong isa) upang mahuli ang pagbubukod. Kung walang catch block, pagkatapos ay wakasan namin ang kasalukuyang pamamaraan, at ang pamamaraan na tumawag sa amin ay nagsasagawa ng parehong pagsusuri."

"Sa tingin ko nakuha ko na ngayon."

"Magaling."

"Ano ang ibig sabihin ng 'Exception' sa loob ng catch statement?"

" Ang lahat ng mga exception ay mga klase na nagmamana ng klase ng Exception. Mahuhuli natin ang isang partikular na exception sa pamamagitan ng pagtukoy ng exception class sa catch block, o maaari nating makuha ang lahat ng exception sa pamamagitan ng pagtukoy sa kanilang karaniwang parent class – Exception. Pagkatapos ay makukuha natin ang lahat ng kinakailangang error impormasyon mula sa variable na e (nag-iimbak ito ng reference sa exception object)."

"Astig! Kung iba't ibang exception ang nangyari sa aking pamamaraan, maaari ko bang iproseso ang mga ito nang iba?"

"Hindi lang kaya mo, pero dapat. Magagawa mo iyan ng ganito:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (NullPointerException e)
        {
           System.out.println("Null reference. Exception has been caught");
        }
        catch (ArithmeticException e)
        {
            System.out.println("Division by zero. Exception has been caught");
        }
        catch (Exception e)
        {
            System.out.println("Any other errors. Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

"Ang try block ay maaaring ipares sa ilang catch block, na ang bawat isa ay makakahuli ng mga tinukoy na uri ng mga exception."

"I think I understand. I can't write this myself yet, but if I found it in code, hindi ako matatakot."