Kivételek a Java nyelven

Helló! A mai leckében a Java-kivételekről fogunk beszélni. A mindennapok tele vannak olyan helyzetekkel, amelyekre nem számítunk. Például reggel felkelsz a munkahelyedre és keresed a telefonod töltőjét, de nem találod sehol. Kimész a mosdóba zuhanyozni, és rájössz, hogy a csövek befagytak. Beülsz az autódba, de nem indul el. Az ember könnyen megbirkózik az ilyen előre nem látható körülményekkel. Ebben a cikkben megpróbáljuk kitalálni, hogy a Java programok hogyan kezelik ezeket.

Mi a Java kivétel?

A programozási világban a program végrehajtása során fellépő hibákat és előre nem látható helyzeteket kivételnek nevezzük. Egy programban kivételek fordulhatnak elő érvénytelen felhasználói műveletek, elégtelen lemezterület vagy a kiszolgálóval való hálózati kapcsolat megszakadása miatt. Kivételek adódhatnak programozási hibákból vagy egy API helytelen használatából is. A való világban élő emberekkel ellentétben egy programnak pontosan tudnia kell, hogyan kell kezelni ezeket a helyzeteket. Ehhez a Java rendelkezik egy kivételkezelésként ismert mechanizmussal.

Néhány szó a kulcsszavakról

A Java kivételkezelése a következő kulcsszavak használatán alapul a programban:

• try - meghatároz egy kódblokkot, ahol kivétel fordulhat elő;
• catch - meghatároz egy kódblokkot, ahol a kivételeket kezelik;
• végül - egy opcionális kódblokkot határoz meg, amely, ha van, a try blokk eredményétől függetlenül végrehajtódik.

Ezekkel a kulcsszavakkal speciális konstrukciókat hoznak létre a kódban: try{}catch , try{}catch{}finally , try{}finally{} .

• dobás – kivétel emelésére szolgál;
• throws – a metódus aláírásában használatos, hogy figyelmeztesse, hogy a metódus kivételt dobhat.

Példa kulcsszavak használatára Java programban:

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

Miért van szükségünk kivételekre?

Nézzünk egy példát a való világból. Képzelje el, hogy az autópálya egy szakaszán van egy kis híd, amelynek teherbírása korlátozott. Ha egy, a híd határánál nehezebb autó áthajt rajta, összedőlhet. A sofőr helyzete finoman szólva is kivételessé válna. Ennek elkerülése érdekében a közlekedési osztály figyelmeztető táblákat helyez el az utakon, mielőtt bármi baj történne. A figyelmeztető tábla láttán a sofőr összehasonlítja járműve tömegét a híd maximális tömegével. Ha a jármű túl nehéz, a vezető elkerülő utat választ. A közlekedési osztály egyrészt lehetővé tette a kamionsofőrök számára, hogy szükség esetén útvonalat változtassanak, másrészt figyelmeztette a sofőröket a főút veszélyeire, harmadszor pedig arra, hogy a hidat bizonyos körülmények között nem szabad használni. A kivételek alkalmazásának egyik oka a Java-ban a kivételek alkalmazásának egyik oka a programban előforduló kivételes helyzetek megelőzésének és megoldásának képessége, amely lehetővé teszi a program futtatását. A kivételi mechanizmus azt is lehetővé teszi, hogy megvédje kódját (API) a helytelen használattól a bemenetek érvényesítésével (ellenőrzésével). Most képzeld el, hogy egy pillanatra te vagy a közlekedési osztály. Először is ismernie kell azokat a helyeket, ahol az autósok bajra számíthatnak. Másodszor, figyelmeztető táblákat kell létrehoznia és telepítenie. Végül pedig kerülőutakat kell biztosítani, ha problémák merülnek fel a főútvonalon. A Java-ban a kivételi mechanizmus hasonló módon működik. A fejlesztés során egy try blokkot használunk, hogy "kivételes korlátokat" építsünk a kód veszélyes szakaszai köré, "tartalék útvonalakat" biztosítunk egy catch {} segítségével.blokkot, és olyan kódot írunk, amelynek le kell futnia, függetlenül attól, hogy mi legyen a végleges{} blokkban. Ha nem tudunk „tartalék útvonalat” biztosítani, vagy választási jogot akarunk adni a felhasználónak, akkor legalább figyelmeztetnünk kell a veszélyre. Miért? Képzeljük csak el egy sofőr felháborodását, aki anélkül, hogy egyetlen figyelmeztető táblát is látna, elér egy kis hídhoz, amelyen nem tud átmenni! A programozás során, amikor osztályainkat és metódusainkat írjuk, nem mindig láthatjuk előre, hogy más fejlesztők hogyan használhatják őket. Ennek eredményeként nem tudjuk előre látni a 100%-ban helyes módját egy kivételes helyzet megoldásának. Ennek ellenére jó forma figyelmeztetni másokat a kivételes helyzetek lehetőségére. A Java kivétel mechanizmusa lehetővé teszi, hogy ezt a dobásokkal is megtegyükkulcsszó – lényegében annak kinyilvánítása, hogy metódusunk általános viselkedése magában foglalja a kivételt. Így bárki, aki ezt a módszert használja, tudja, hogy kódot kell írnia a kivételek kezelésére.

Mások figyelmeztetése a "bajra"

Ha nem tervezi a kivételek kezelését módszerében, de figyelmeztetni szeretne másokat, hogy kivételek előfordulhatnak, használja a throws kulcsszót. Ez a kulcsszó a metódus aláírásában azt jelenti, hogy bizonyos feltételek mellett a metódus kivételt jelenthet. Ez a figyelmeztetés a metódus felületének része, és lehetővé teszi a felhasználók számára, hogy megvalósítsák saját kivételkezelési logikájukat. A dobások után megadjuk a dobott kivételek típusait. Ezek általában a Java Exception osztályából származnak. Mivel a Java egy objektumorientált nyelv, minden kivétel Java objektum.

Kivételi hierarchia

Ha egy program futása közben hiba történik, a JVM létrehoz egy megfelelő típusú objektumot a Java kivételhierarchiából – lehetséges kivételek halmazából, amelyek egy közös őstől – a Throwable osztálytól – származnak . A kivételes futásidejű helyzeteket két csoportra oszthatjuk:

1. Olyan helyzetek, amelyekből a program nem tud helyreállni és folytatni a normál működést.
2. Olyan helyzetek, amikor a helyreállítás lehetséges.

Az első csoportba azok a helyzetek tartoznak, amelyekben a Hiba osztályból származó kivételek vannak . Ezek olyan hibák, amelyek JVM hibás működése, memória túlcsordulás vagy rendszerhiba miatt fordulnak elő. Általában súlyos problémákat jeleznek, amelyeket szoftverrel nem lehet kijavítani. Java-ban az ilyen kivételek lehetőségét a fordító nem ellenőrzi, ezért ezeket ellenőrizetlen kivételeknek nevezzük. Ebbe a csoportba tartoznak a RuntimeExceptions kivételek is, amelyek a kivételtől származnakosztályba, és a JVM generálja őket futási időben. Ezeket gyakran programozási hibák okozzák. Ezeket a kivételeket a fordításkor sem ellenőrzik (kivéve), így nem szükséges kódot írni a kezelésükhöz. A második csoportba azok a kivételes helyzetek tartoznak, amelyek előre láthatók a program írásakor (és ezért kódot kell írni ezek kezelésére). Az ilyen kivételeket ellenőrzött kivételeknek nevezzük. Ha a kivételekről van szó, a Java-fejlesztők munkája nagy része az ilyen helyzetek kezelése.

Kivétel létrehozása

Amikor egy program fut, a kivételeket vagy a JVM, vagy manuálisan állítja elő egy throw utasítás használatával . Amikor ez megtörténik, egy kivételobjektum jön létre a memóriában, a program fő folyama megszakad, és a JVM kivételkezelője megpróbálja kezelni a kivételt.

Kivételkezelés

A Java-ban kódblokkokat hozunk létre, ahol a try{}catch , try{}catch{}finally és try{}finally{} konstrukciók segítségével előre látjuk a kivételkezelés szükségességét. Ha kivételt dob ​​egy try blokkban, a JVM megfelelő kivételkezelőt keres a következő fogási blokkban. Ha egy fogási blokk rendelkezik a szükséges kivételkezelővel, a vezérlés átadja neki. Ha nem, akkor a JVM tovább néz a fogási blokkok láncában, amíg meg nem találja a megfelelő kezelőt. A fogási blokk végrehajtása után a vezérlés átkerül az opcionális végső blokkra. Ha megfelelő fogásblokk nem található, akkor a JVM leállítja a programot és megjeleníti a verem nyomkövetést (a metódushívások aktuális veremét), miután először végrehajtotta a végső blokkot, ha létezik. Példa kivételkezelésre:

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

    }
    }

Íme a fő módszer eredményei:

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

A final általában minden adatfolyam bezárására és a try blokkban megnyitott/lefoglalt erőforrások felszabadítására szolgál. Egy program írásakor azonban nem mindig lehet nyomon követni az összes erőforrás bezárását. Életünk megkönnyítése érdekében a Java fejlesztői felajánlják a try-with-resources konstrukciót, amely automatikusan bezár minden, a try blokkban megnyitott erőforrást. Az első példánk újraírható a "try-with-source" segítségével :

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

A 7-es verzióban bevezetett Java képességeknek köszönhetően a heterogén kivételek elkapását is egy blokkba tudjuk kombinálni, így a kód kompaktabbá és olvashatóbbá válik. Példa:

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

Alsó vonal

A Java kivételek használatával robusztusabbá teheti programjait azáltal, hogy "mentési útvonalakat" hoz létre, elkapó blokkokat használjon a fő kód és a kivételkezelő kód elválasztására, és dobások segítségével átruházhatja a kivételkezelés felelősségét arra, aki az Ön módszerét használja .