Excepții în Java

Buna ziua! În lecția de astăzi, vom vorbi despre excepțiile Java. Viața de zi cu zi este plină de situații pe care nu le anticipăm. De exemplu, te trezești dimineața la serviciu și cauți încărcătorul telefonului, dar nu-l găsești nicăieri. Te duci la baie la duș doar pentru a descoperi că țevile sunt înghețate. Te urci în mașină, dar nu pornește. Un om este capabil să facă față cu ușurință unor astfel de circumstanțe neprevăzute. În acest articol, vom încerca să ne dăm seama cum le abordează programele Java.

Ce este o excepție Java?

În lumea programării, erorile și situațiile neprevăzute în execuția unui program sunt numite excepții. Într-un program, pot apărea excepții din cauza acțiunilor nevalide ale utilizatorului, a spațiului insuficient pe disc sau a pierderii conexiunii de rețea cu serverul. Excepțiile pot rezulta și din erori de programare sau din utilizarea incorectă a unui API. Spre deosebire de oamenii din lumea reală, un program trebuie să știe exact cum să gestioneze aceste situații. Pentru aceasta, Java are un mecanism cunoscut sub numele de gestionarea excepțiilor.

Câteva cuvinte despre cuvinte cheie

Gestionarea excepțiilor în Java se bazează pe utilizarea următoarelor cuvinte cheie în program:

• try - definește un bloc de cod în care poate apărea o excepție;
• catch - definește un bloc de cod în care sunt gestionate excepțiile;
• în final - definește un bloc opțional de cod care, dacă este prezent, este executat indiferent de rezultatele blocului try.

Aceste cuvinte cheie sunt folosite pentru a crea constructe speciale în cod: try{}catch , try{}catch{}finally , try{}finally{} .

• arunca - folosit pentru a ridica o excepție;
• throws - folosit în semnătura metodei pentru a avertiza că metoda poate arunca o excepție.

Un exemplu de utilizare a cuvintelor cheie într-un program Java:

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

De ce avem nevoie de excepții?

Să ne uităm la un exemplu din lumea reală. Imaginați-vă că o secțiune a unei autostrăzi are un pod mic cu o capacitate de greutate limitată. Dacă o mașină mai grea decât limita podului trece peste el, s-ar putea prăbuși. Situația șoferului ar deveni, ca să spunem ușor, excepțională. Pentru a evita acest lucru, departamentul de transport instalează semne de avertizare pe drum înainte ca ceva să meargă prost. Văzând semnul de avertizare, un șofer compară greutatea vehiculului său cu greutatea maximă a podului. Dacă vehiculul este prea greu, șoferul urmează o rută de ocolire. Departamentul de transport, în primul rând, a făcut posibil ca șoferii de camioane să își schimbe traseul dacă este necesar, în al doilea rând, i-a avertizat pe șoferi despre pericolele de pe drumul principal, iar în al treilea rând, i-a avertizat pe șoferi că podul nu trebuie utilizat în anumite condiții. Abilitatea de a preveni și rezolva situații excepționale într-un program, permițându-i acestuia să continue să ruleze, este un motiv pentru utilizarea excepțiilor în Java. Mecanismul de excepție vă permite, de asemenea, să vă protejați codul (API) împotriva utilizării necorespunzătoare prin validarea (verificarea) oricăror intrări. Acum imaginați-vă că sunteți departamentul de transport pentru o secundă. În primul rând, trebuie să cunoașteți locurile în care șoferii se pot aștepta la probleme. În al doilea rând, trebuie să creați și să instalați semne de avertizare. Și, în sfârșit, trebuie să oferiți ocoluri dacă apar probleme pe ruta principală. În Java, mecanismul de excepție funcționează într-un mod similar. În timpul dezvoltării, folosim un bloc de încercare pentru a construi „bariere de excepție” în jurul secțiunilor periculoase de cod, oferim „rute de rezervă” folosind o captură {}bloc și scriem cod care ar trebui să ruleze indiferent de ce într-un bloc final{} . Dacă nu putem oferi o „rută de rezervă” sau dorim să acordăm utilizatorului dreptul de a alege, trebuie cel puțin să-l avertizăm asupra pericolului. De ce? Imaginați-vă doar indignarea unui șofer care, fără să vadă un singur semn de avertizare, ajunge pe un pod mic pe care nu-l poate trece! În programare, când scriem clasele și metodele noastre, nu putem prevedea întotdeauna cum ar putea fi folosite de alți dezvoltatori. Ca urmare, nu putem prevedea modalitatea 100% corectă de a rezolva o situație excepțională. Acestea fiind spuse, este o formă bună să îi avertizi pe alții despre posibilitatea unor situații excepționale. Mecanismul de excepție al Java ne permite să facem acest lucru cu aruncărilecuvânt cheie — în esență o declarație că comportamentul general al metodei noastre include aruncarea unei excepții. Astfel, oricine folosește metoda știe că ar trebui să scrie cod pentru a gestiona excepțiile.

Avertizând pe alții despre „probleme”

Dacă nu intenționați să gestionați excepții în metoda dvs., dar doriți să îi avertizați pe alții că pot apărea excepții, utilizați cuvântul cheie throws . Acest cuvânt cheie din semnătura metodei înseamnă că, în anumite condiții, metoda poate arunca o excepție. Acest avertisment face parte din interfața metodei și le permite utilizatorilor săi implementeze propria logică de gestionare a excepțiilor. După aruncări, specificăm tipurile de excepții aruncate. Acestea descind de obicei din clasa Exception a Java . Deoarece Java este un limbaj orientat pe obiecte, toate excepțiile sunt obiecte în Java.

Ierarhia excepțiilor

Când apare o eroare în timp ce un program rulează, JVM creează un obiect de tipul adecvat din ierarhia excepțiilor Java - un set de excepții posibile care descind dintr-un strămoș comun - clasa Throwable . Putem împărți situațiile excepționale de rulare în două grupuri:

1. Situații din care programul nu se poate recupera și continua funcționarea normală.
2. Situații în care recuperarea este posibilă.

Primul grup include situații care implică o excepție care descinde din clasa Error . Acestea sunt erori care apar din cauza unei defecțiuni JVM, a depășirii memoriei sau a unei defecțiuni a sistemului. Ele indică de obicei probleme grave care nu pot fi rezolvate de software. În Java, posibilitatea unor astfel de excepții nu este verificată de compilator, așa că sunt cunoscute ca excepții neverificate. Acest grup include, de asemenea, RuntimeExceptions, care sunt excepții care descind de la Excepțieclasa și sunt generate de JVM în timpul rulării. Acestea sunt adesea cauzate de erori de programare. De asemenea, aceste excepții nu sunt bifate (nebifate) în timpul compilării, așa că nu vi se cere să scrieți cod pentru a le gestiona. Al doilea grup include situații excepționale care pot fi prevăzute atunci când scrieți programul (și astfel ar trebui să scrieți cod pentru a le gestiona). Astfel de excepții se numesc excepții verificate. Când vine vorba de excepții, cea mai mare parte a muncii unui dezvoltator Java se ocupă de astfel de situații.

Crearea unei excepții

Când rulează un program, excepțiile sunt generate fie de JVM, fie manual folosind o instrucțiune throw . Când se întâmplă acest lucru, un obiect excepție este creat în memorie, fluxul principal al programului este întrerupt și handlerul de excepție al JVM-ului încearcă să gestioneze excepția.

Tratarea excepțiilor

În Java, creăm blocuri de cod în care anticipăm necesitatea gestionării excepțiilor folosind constructele try{}catch , try{}catch{}finally și try{}finally{} . Când o excepție este aruncată într-un bloc try , JVM caută un handler de excepție adecvat în următorul bloc catch . Dacă un bloc catch are handlerul de excepții necesar, controlul îi trece. Dacă nu, atunci JVM-ul caută mai departe în lanțul de blocuri de captură până când este găsit handlerul corespunzător. După executarea unui bloc catch , controlul este transferat către blocul final opțional . Dacă o captură potrivităblocul nu este găsit, apoi JVM oprește programul și afișează urmărirea stivei (stiva curentă de apeluri de metodă), după ce mai întâi a efectuat blocul final , dacă acesta există. Exemplu de tratare a excepțiilor:

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

    }
    }

Iată rezultatele metodei principale :

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

Finally este de obicei folosit pentru a închide orice flux și a elibera orice resurse deschise/alocate într-un bloc try . Cu toate acestea, atunci când scrieți un program, nu este întotdeauna posibil să urmăriți închiderea tuturor resurselor. Pentru a ne ușura viața, dezvoltatorii Java oferă construcția try-with-resources , care închide automat orice resurse deschise într-un bloc try . Primul nostru exemplu poate fi rescris cu 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;
}

Datorită capabilităților Java introduse în versiunea 7, putem combina și capturarea excepțiilor eterogene într-un singur bloc, făcând codul mai compact și mai lizibil. Exemplu:

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

Linia de jos

Folosirea excepțiilor în Java vă permite să vă faceți programele mai robuste prin crearea de „rute de rezervă”, să utilizați blocuri catch pentru a separa codul principal de codul de gestionare a excepțiilor și să utilizați throws pentru a transfera responsabilitatea gestionării excepțiilor către oricine vă folosește metoda.