Mga uri ng pagbubukod

"Gusto kong pag-usapan ang isa pang bagay ngayon. Sa Java, ang lahat ng exception ay nahahati sa dalawang uri: checked at unchecked (yung dapat mahuli at hindi mo kailangang hulihin). Bilang default, lahat ng exception ay kailangang nahuli."

"Maaari mo bang sadyang magtapon ng mga pagbubukod sa iyong code?"

"Maaari kang maghagis ng anumang exception sa sarili mong code. Maaari ka ring magsulat ng sarili mong mga exception. Ngunit pag-uusapan natin iyon mamaya. Sa ngayon, tumutok tayo sa mga exception na ibinabato ng Java Machine."

"OK."

"Kung ang ClassNotFoundException o FileNotFoundException ay itinapon (nagaganap) sa isang paraan, dapat ipahiwatig ng developer ang mga ito sa deklarasyon ng pamamaraan. Ito ay mga naka-check na exception. Ganito ang karaniwang hitsura nito:"

public static void method1() throws ClassNotFoundException, FileNotFoundException

public static void main() throws IOException

public static void main() // Doesn't throw any exceptions

"Kaya nagsusulat na lang kami ng 'throws' na sinusundan ng isang comma-delimited list of exceptions, di ba?"

"Oo. Ngunit marami pa. Para mag-compile ang program, ang paraan na tumatawag method1sa halimbawa sa ibaba ay dapat na gumawa ng isa sa dalawang bagay: alinman sa hulihin ang mga pagbubukod na ito o ibalik ang mga ito (sa tumatawag) , na nagpapahiwatig ng mga rethrown exception sa deklarasyon nito. "

"Muli. Kung ang iyong pangunahing pamamaraan ay kailangang tumawag ng isang paraan na ang deklarasyon ay naglalaman ng ' throws FileNotFoundException , ...', pagkatapos ay kailangan mong gawin ang isa sa dalawang bagay:

1) Mahuli ang FileNotFoundException , …

Dapat mong i-wrap ang code na tumatawag sa hindi ligtas na paraan sa isang try-catch block.

2) Huwag mahuli ang FileNotFoundException , ...

Dapat mong idagdag ang mga pagbubukod na ito sa listahan ng mga throws ng iyong pangunahing pamamaraan."

"Maaari mo ba akong bigyan ng halimbawa?"

"Tignan mo ito:"

public static void main(String[] args)
{
    method1();
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

"Ang code sa halimbawang ito ay hindi mag-compile, dahil ang pangunahing pamamaraan ay tumatawag sa method1() , na nagtatapon ng mga pagbubukod na kailangang mahuli."

"Upang gawin itong compile, kailangan naming magdagdag ng exception handling sa pangunahing paraan. Magagawa mo ito sa isa sa dalawang paraan:"

public static void main(String[] args)  throws FileNotFoundException, ClassNotFoundException
{
    method1();
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

"At narito, hinuhuli natin ito ng isang try-catch :"

public static void main(String[] args)
{
    try
    {
        method1();
    }
    catch(Exception e)
    {
    }
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

"Nagsisimula na itong maging mas malinaw."

"Tingnan mo ang sumusunod na halimbawa. Makakatulong ito sa iyo na maunawaan ang iba pa."

public static void method2() throws FileNotFoundException, ClassNotFoundException
{
    method1();
}

public static void method3() throws ClassNotFoundException
{
   try
    {
        method1();
    }
    catch (FileNotFoundException e)
    {
        System.out.println("FileNotFoundException has been caught.");
    }
}

public static void method4()
{
    try
    {
        method1();
    }
    catch (FileNotFoundException e)
    {
        System.out.println("FileNotFoundException has been caught.");
    }
    catch (ClassNotFoundException e)
    {
        System.out.println("ClassNotFoundException has been caught.");
    }
}

"May isa pang uri ng pagbubukod, ang RuntimeException at mga klase na nagmamana nito. Hindi mo kailangang mahuli ang mga ito. Ang mga ito ay hindi naka-check na mga pagbubukod. Itinuturing silang mahirap hulaan. Maaari mong harapin ang mga ito sa parehong paraan, ngunit ikaw hindi kailangang ipahiwatig ang mga ito sa isang throws clause."