Mga pagbubukod sa Java

Kamusta! Sa aralin ngayon, pag-uusapan natin ang tungkol sa Java Exceptions. Ang pang-araw-araw na buhay ay puno ng mga sitwasyon na hindi natin inaasahan. Halimbawa, gumising ka para sa trabaho sa umaga at hanapin ang charger ng iyong telepono, ngunit hindi mo ito mahahanap kahit saan. Pumunta ka sa banyo upang maligo para lamang matuklasan na ang mga tubo ay nagyelo. Sumakay ka sa iyong sasakyan, ngunit hindi ito magsisimula. Ang isang tao ay madaling makayanan ang mga hindi inaasahang pangyayari. Sa artikulong ito, susubukan naming malaman kung paano nakikitungo ang mga programa sa Java sa kanila.

Ano ang Java exception?

Sa mundo ng programming, ang mga pagkakamali at hindi inaasahang sitwasyon sa pagpapatupad ng isang programa ay tinatawag na mga eksepsiyon. Sa isang programa, maaaring mangyari ang mga pagbubukod dahil sa mga di-wastong aksyon ng user, hindi sapat na espasyo sa disk, o pagkawala ng koneksyon sa network sa server. Ang mga pagbubukod ay maaari ding magresulta mula sa mga error sa programming o maling paggamit ng isang API. Hindi tulad ng mga tao sa totoong mundo, dapat alam ng isang programa kung paano haharapin ang mga sitwasyong ito. Para dito, may mekanismo ang Java na kilala bilang exception handling.

Ilang salita tungkol sa mga keyword

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 isang bloke ng code kung saan pinangangasiwaan ang mga pagbubukod;
• sa wakas - tumutukoy sa isang opsyonal na bloke ng code na, kung naroroon, ay isinasagawa anuman ang mga resulta ng bloke ng pagsubok.

Ang mga keyword na ito ay ginagamit upang lumikha ng mga espesyal na construct sa code: subukan{}catch , try{}catch{}finally , try{}finally{} .

• itapon - ginagamit upang itaas ang isang pagbubukod;
• throws - ginagamit sa signature ng pamamaraan upang bigyan ng babala na ang pamamaraan ay maaaring magtapon ng exception.

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

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn 
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the 
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException  
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

Bakit kailangan natin ng mga eksepsiyon?

Tingnan natin ang isang halimbawa mula sa totoong mundo. Isipin na ang isang seksyon ng isang highway ay may maliit na tulay na may limitadong kapasidad ng timbang. Kung ang isang kotse na mas mabigat kaysa sa limitasyon ng tulay ay dumaan dito, maaari itong bumagsak. Ang sitwasyon para sa driver ay magiging, sa madaling salita, katangi-tangi. Upang maiwasan ito, ang departamento ng transportasyon ay naglalagay ng mga karatula ng babala sa kalsada bago magkaroon ng mali. Nang makita ang babala, ikinukumpara ng tsuper ang bigat ng kanyang sasakyan sa pinakamataas na bigat para sa tulay. Kung ang sasakyan ay masyadong mabigat, ang driver ay dadaan sa isang bypass na ruta. Ang departamento ng transportasyon, una, ay ginawang posible para sa mga tsuper ng trak na baguhin ang kanilang ruta kung kinakailangan, pangalawa, binalaan ang mga driver tungkol sa mga panganib sa pangunahing kalsada, at pangatlo, binalaan ang mga driver na ang tulay ay hindi dapat gamitin sa ilang mga kondisyon. Ang kakayahang pigilan at lutasin ang mga pambihirang sitwasyon sa isang programa, na nagpapahintulot na magpatuloy itong tumakbo, ay isang dahilan para sa paggamit ng mga eksepsiyon sa Java. Hinahayaan ka rin ng mekanismo ng pagbubukod na protektahan ang iyong code (API) mula sa hindi wastong paggamit sa pamamagitan ng pag-validate (pagsuri) ng anumang mga input. Ngayon isipin na ikaw ang departamento ng transportasyon sa isang segundo. Una, kailangan mong malaman ang mga lugar kung saan maaaring asahan ng mga motorista ang gulo. Pangalawa, kailangan mong lumikha at mag-install ng mga palatandaan ng babala. At sa wakas, kailangan mong magbigay ng mga detour kung lumitaw ang mga problema sa pangunahing ruta. Sa Java, ang mekanismo ng pagbubukod ay gumagana sa katulad na paraan. Sa panahon ng pag-unlad, gumagamit kami ng try block upang bumuo ng "mga hadlang sa pagbubukod" sa paligid ng mga mapanganib na seksyon ng code, nagbibigay kami ng "mga backup na ruta" gamit ang isang catch {}block, at nagsusulat kami ng code na dapat tumakbo kahit na ano sa isang block sa wakas{} . Kung hindi kami makapagbigay ng "backup na ruta" o gusto naming bigyan ang gumagamit ng karapatang pumili, dapat namin siyang bigyan ng babala man lang tungkol sa panganib. Bakit? Isipin na lang ang galit ng isang tsuper na, nang walang nakikitang karatulang babala, ay umabot sa isang maliit na tulay na hindi niya makatawid! Sa programming, kapag isinusulat ang aming mga klase at pamamaraan, hindi namin laging mahulaan kung paano sila magagamit ng ibang mga developer. Bilang resulta, hindi namin mahulaan ang 100% tamang paraan upang malutas ang isang pambihirang sitwasyon. Sabi nga, magandang paraan para balaan ang iba tungkol sa posibilidad ng mga pambihirang sitwasyon. Hinahayaan tayo ng mekanismo ng pagbubukod ng Java na gawin ito sa mga throwskeyword — mahalagang deklarasyon na kasama sa pangkalahatang gawi ng aming pamamaraan ang paghahagis ng exception. Kaya, alam ng sinumang gumagamit ng pamamaraan na dapat siyang sumulat ng code upang mahawakan ang mga pagbubukod.

Babala sa iba tungkol sa "gulo"

Kung wala kang planong pangasiwaan ang mga pagbubukod sa iyong pamamaraan, ngunit gusto mong bigyan ng babala ang iba na maaaring mangyari ang mga pagbubukod, gamitin ang keyword na throws . Ang keyword na ito sa 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 hinahayaan ang mga user nito na ipatupad ang kanilang sariling lohika sa paghawak ng exception. Pagkatapos ng mga throw, tinutukoy namin ang mga uri ng mga exception na itinapon. Karaniwang bumababa ang mga ito mula sa klase ng Exception ng Java . Dahil ang Java ay isang object-oriented na wika, lahat ng exception ay mga object sa Java.

Exception hierarchy

Kapag may naganap na error habang tumatakbo ang isang program, gagawa ang JVM ng isang bagay na may naaangkop na uri mula sa Java exception hierarchy — isang hanay ng mga posibleng exception na nagmula sa isang karaniwang ninuno — ang Throwable class . Maaari naming hatiin ang mga pambihirang sitwasyon ng runtime sa dalawang grupo:

1. Mga sitwasyon kung saan ang programa ay hindi maaaring mabawi at magpatuloy sa normal na operasyon.
2. Mga sitwasyon kung saan posible ang pagbawi.

Kasama sa unang pangkat ang mga sitwasyong kinasasangkutan ng isang pagbubukod na bumaba mula sa klase ng Error . Ito ay mga error na nangyayari dahil sa isang malfunction ng JVM, overflow ng memory, o pagkabigo ng system. Karaniwang nagpapahiwatig ang mga ito ng mga seryosong problema na hindi naaayos ng software. Sa Java, ang posibilidad ng naturang mga eksepsiyon ay hindi sinusuri ng compiler, kaya ang mga ito ay kilala bilang hindi naka-check na mga eksepsiyon. Kasama rin sa pangkat na ito ang RuntimeExceptions, na mga exception na bumaba mula sa Exceptionclass at nabuo ng JVM sa oras ng pagtakbo. Ang mga ito ay kadalasang sanhi ng mga error sa programming. Ang mga pagbubukod na ito ay hindi rin naka-check (hindi naka-check) sa oras ng pag-compile, kaya hindi mo kailangang magsulat ng code upang mahawakan ang mga ito. Kasama sa pangalawang grupo ang mga pambihirang sitwasyon na maaaring mahulaan kapag isinusulat mo ang programa (at kaya dapat kang sumulat ng code upang mahawakan ang mga ito). Ang mga naturang exception ay tinatawag na checked exceptions. Pagdating sa mga pagbubukod, karamihan sa gawain ng isang developer ng Java ay humahawak sa mga ganitong sitwasyon.

Paglikha ng exception

Kapag ang isang programa ay tumatakbo, ang mga pagbubukod ay nabuo alinman sa pamamagitan ng JVM o mano-mano gamit ang isang throw statement. Kapag nangyari ito, ang isang exception object ay nilikha sa memorya, ang pangunahing daloy ng programa ay naaantala, at ang exception handler ng JVM ay sumusubok na pangasiwaan ang exception.

Exception handling

Sa Java, lumikha kami ng mga bloke ng code kung saan inaasahan namin ang pangangailangan para sa paghawak ng exception gamit ang try{}catch , try{}catch{}finally , at subukan{}finally{} constructs. Kapag ang isang exception ay itinapon sa isang try block, ang JVM ay naghahanap ng isang naaangkop na exception handler sa susunod na catch block. Kung ang catch block ay may kinakailangang exception handler, ang control ay pumasa dito. Kung hindi, ang JVM ay tumitingin sa kadena ng mga bloke ng catch hanggang sa matagpuan ang naaangkop na handler. Pagkatapos magsagawa ng catch block, ang kontrol ay ililipat sa opsyonal na finally block. Kung angkop na hulihindi nahanap ang block, pagkatapos ay ihihinto ng JVM ang programa at ipinapakita ang stack trace (ang kasalukuyang stack ng mga tawag sa pamamaraan), pagkatapos munang isagawa ang panghuling bloke kung mayroon ito. Halimbawa ng paghawak ng exception:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + 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 handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

Narito ang mga resulta ng pangunahing pamamaraan:

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

Ang panghuli ay karaniwang ginagamit upang isara ang anumang mga stream at palayain ang anumang mga mapagkukunang binuksan/inilalaan sa isang bloke ng pagsubok . Gayunpaman, kapag nagsusulat ng isang programa, hindi laging posible na subaybayan ang pagsasara ng lahat ng mga mapagkukunan. Upang gawing mas madali ang ating buhay, ang mga developer ng Java ay nag-aalok ng try-with-resources construct, na awtomatikong nagsasara ng anumang mga mapagkukunang binuksan sa isang try block. Ang aming unang halimbawa ay maaaring muling isulat gamit ang 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 ("The string cannot be empty!");
    }
    return s;
}

Salamat sa mga kakayahan ng Java na ipinakilala sa bersyon 7, maaari rin naming pagsamahin ang pagkuha ng mga heterogenous na pagbubukod 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("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Ang ilalim na linya

Ang paggamit ng mga exception sa Java ay nagbibigay-daan sa iyong gawing mas matatag ang iyong mga programa sa pamamagitan ng paglikha ng "mga backup na ruta", gumamit ng mga catch block upang paghiwalayin ang pangunahing code mula sa exception handling code, at gumamit ng mga throws upang ilipat ang responsibilidad para sa exception handling sa sinumang gumagamit ng iyong pamamaraan.