Java throw Exception

Kahit saan tayo magpunta, naghihintay sa atin ang mga hindi inaasahang pangyayari. Mga lindol, hindi makatwiran na pagkilos ng mga tao, meteorite... o isang bagay na mas simple — isang bombilya ang nasusunog, ang isang bank card ay nagde-demagnetize, ang isang gasoline gauge ay nasira. Hindi namin maaaring i-disable ang mga hindi mahuhulaan na kaganapan, ngunit maaari kaming maging bahagyang handa para sa mga ito. Ibig sabihin, dapat tayong maghanda ng ilang mekanismo para harapin ang mga ito. Sa mundo ng programming, partikular sa wikang Java, ang mga kaganapan na pumipigil sa isang programa na gumana nang normal ay tinatawag na mga eksepsiyon, at ang mga mekanismo para sa pagpigil sa mga pag-crash ng programa ay tinatawag na exception handling. Kaya, kapag ang isang hindi inaasahang kaganapan ay nangyari sa isang programa, tulad ng paghahati sa pamamagitan ng zero, dapat itong "magtapon" ng isang pagbubukod. Ang paghawak ng exception ay isang mahalagang aspeto ng Java programming na tumutulong sa mga developer na pamahalaan ang mga error at exception na maaaring mangyari sa panahon ng pagpapatupad ng isang program. Sa artikulong ito, pagtutuunan natin ng pansin ang isa sa mga pangunahing konsepto ng paghawak ng exception: ang Java throw na keyword at kung paano ito gamitin upang maghagis ng exception.

Ano ang Exception sa Java?

Ang pagbubukod ay isang kaganapan na nangyayari sa panahon ng pagpapatupad ng isang programa na nakakagambala sa normal na daloy ng mga tagubilin ng programa. Kapag naganap ang isang pagbubukod, ang pagpapatupad ng programa ay ititigil, at ang mensahe ng error ay ipinapakita sa console. Sa Java, mayroong dalawang uri ng mga exception: checked at unchecked. Ang mga na-check na exception ay sinusuri sa oras ng pag-compile, at tinitiyak ng compiler na sila ay nahuli o idineklara ng paraan ng pagtawag. Sa kabilang banda, ang mga hindi na-check na exception ay hindi nasusuri sa oras ng pag-compile, at maaari silang mahuli o iwanang hindi mahuli. Narito ang isang halimbawa ng code kung saan maaaring magkaroon ng error, ngunit nilalaktawan ito ng compiler.

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Narito ang output ng programa: Ang programa ay lumabas nang tama, ngunit gumawa ng isang hindi tamang resulta. Sa unang kaso, dahil negatibo ang argumento ng function, at hindi gumagana ang factorial para sa mga negatibong numero. Sa pangalawang kaso, mali ang resulta, dahil masyadong malaki ang numero para mabilang ang factorial nito sa hanay ng mahabang uri. Narito ang isa pang halimbawa. Sumulat tayo ng isang programa kung saan hahatiin natin ang isang numero sa isa pa.

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

Sa halimbawang ito, ang isang ArithmeticException ay itatapon dahil ang variable b ay zero. Gayunpaman, ang error na ito ay hindi pinangangasiwaan, kaya lumabas ang programa nang may hindi tamang katayuan.

Paano magtapon ng isang pagbubukod sa Java

Sa Java, ang mga pagbubukod ay mga bagay din, kaya ang isang pagbubukod ay itinapon tulad ng isang bagong bagay na Pagbubukod na nilikha. Ang isang exception ay itinapon sa isang programa gamit ang throw statement. Karaniwan, ang dalawang operasyong ito (paglikha ng bagay at paghahagis ng eksepsiyon) ay pinagsama sa isa:

 throw new Exception("error…");

Ang throw keyword sa Java ay ginagamit upang maghagis ng exception mula sa isang paraan o block ng code kapag may naganap na error o pambihirang kundisyon na hindi mahawakan ng program sa runtime. Ang daloy ng programa ay na-redirect sa pinakamalapit na catch block. Maaaring pamahalaan ng block na ito ang exception.

Halimbawa ng paggamit ng keyword na 'throw'

Upang ilarawan ang functionality ng throw keyword sa Java, kumuha tayo ng halimbawa. Sumulat tayo ng isang paraan upang makalkula ang factorial ng isang numero. Kung ang numero ay negatibo, hindi ito maaaring kalkulahin, kaya ang isang pagbubukod ay dapat itapon. Katulad nito, kung ang bilang ay masyadong malaki, ang factorial na resulta ay lalampas sa maximum na laki ng isang mahabang uri, at isa pang pagbubukod ang itatapon. Narito mayroon kaming pagpapatupad ng pamamaraan:

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here 
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

Sa halimbawang ito, kung ang halaga ng numero ay negatibo, ang throw keyword ay ginagamit upang ihagis ang isang instance ng klase ng IllegalArgumentException . Kung patakbuhin mo ang program, ang mensaheng "The argument isn't legal" ay ipapakita sa console. Ang pagpapatupad ng programa ay ititigil.

Wala nang mga error: pagkuha ng isang halimbawa ng pagbubukod

Ngayon, alalahanin natin ang pangalawang halimbawa, na may dibisyon sa pamamagitan ng zero, at isagawa ito nang may exception handling.

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Sa halimbawang ito, nagdagdag kami ng try-catch construct para pangasiwaan ang division-by-zero exception. Sa madaling sabi, ang try-catch-finally ay isang Java programming language construct na nagbibigay-daan sa iyong pangasiwaan ang mga exception at execute ang code kahit na may naganap na exception o hindi. try-catch-finally ay binubuo ng tatlong bloke:

• Ang try block. Ang potensyal na mapanganib na code ay isinasagawa dito. Iyon ay code na maaaring magtapon ng exception. Kung ang isang exception ay nangyari sa loob ng isang try block, ang pagpapatupad ng code sa block na iyon ay aborted, at ang kontrol ay ililipat sa catch block.
• Ang catch block. Dito pinangangasiwaan ang itinapon na pagbubukod. Sa catch block, maaari mong tukuyin kung aling exception ang mahuhuli at kung anong logic ang isasagawa kapag ito ay nahuli.
Ang pangwakas na bloke. Ang isang ito ay isinasagawa kahit na may naganap na pagbubukod o hindi. Ang panghuling block ay ginagamit, halimbawa, upang maglabas ng mga mapagkukunan (tulad ng pagsasara ng isang file o socket) na inilaan sa isang try block. Maaari mong alisin ang block na ito.

Ang try-catch-finally construct ay nagbibigay-daan para sa mas tumpak na kontrol sa pagpapatupad ng programa sa kaganapan ng mga pambihirang sitwasyon at nakakatulong na maiwasan ang hindi inaasahang pagwawakas ng programa kung sakaling magkaroon ng mga error. Ngayon, bumalik tayo sa ating halimbawa. Kung ang paghahati sa pamamagitan ng zero ay nangyari sa panahon ng paraan ng paghahati, isang ArithmeticException ang itatapon, na nahuhuli ng catch block. Sa catch block, nagpi-print lang kami ng mensahe ng error sa console. Kung walang pagbubukod, ang programa ay magpapatuloy sa pagpapatupad nito.

nagtatapon ng keyword

Ang mga throws na keyword ay ginagamit sa lagda ng pamamaraan. Kung gayon, nangangahulugan ito na ang isang pagbubukod ay itinapon sa pamamaraan. Maaari itong magpalaganap ng mga pagbubukod sa stack ng tawag at ipahiwatig na ang mga pagbubukod ay hindi kailangang pangasiwaan sa kasalukuyang pamamaraan. Sa Java, ang "throws" ay maaari ding gamitin upang sumangguni sa mga custom na exception na tinukoy sa isang programa. Halimbawa, ang isang pamamaraan ay maaaring magsagawa ng dibisyon ng dalawang numero ngunit magtapon ng IllegalArgumentException kung ang pangalawang argumento ay zero:

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Ang pamamaraang ito ay gumagamit ng mga throws na keyword upang ipahiwatig na ang isang IllegalArgumentException ay maaaring ihagis kung ang pangalawang argumento ay null. Kung nangyari ang naturang pagbubukod habang isinasagawa ang pamamaraan, ipapasa ito sa paraan ng pagtawag para sa pagproseso. Halimbawa ng paraan ng tawag:

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

Sa halimbawang ito, ang divide() na pamamaraan ay tinatawag na may mga argumento 10 at 0, na maghahagis ng IllegalArgumentException dahil imposible ang paghahati sa pamamagitan ng zero. Ang pagbubukod ay mahuhuli ng isang try-catch block, at isang mensahe ng error ang ipapakita. Ang programa ay magreresulta sa isang halaga ng zero dahil ang pagbubukod ay nagtatapos sa pagpapatupad ng divide() na paraan.