1. díl - Výjimky v Javě

Java Práce se soubory Výjimky v Javě

V této sekci se budeme věnovat práci se soubory. Než však můžeme začít zapisovat a číst, měli bychom vyřešit, jak ošetřit chybové stavy programu, kterých při práci se soubory bude nastávat mnoho.

V našem programu může často dojít k chybě. Tím nemyslím chybě z důvodu, že byl program funkčně špatně napsaný, takových chyb se jsme schopni dobře vyvarovat. Obecně se jedná zejména o chyby, které zapříčinily tzv. vstupně/výstupní operace. V anglické literatuře se hovoří o input/output nebo zkráceně o IO. Jedná se např. o vstup uživatele z konzole, ze souboru, výstup do souboru, na tiskárnu a podobně. V zásadě platí, že zde figuruje uživatel, který nám může zadat nesmyslný vstup, neexistující nebo nevalidní soubor, odpojit tiskárnu a podobně. My však nenecháme program spadnout s chybou, naopak budeme zranitelná místa v programu ošetřovat a na danou skutečnost uživatele upozorníme.

Aktivní ošetření chyb

První možnost ošetření chyb nazýváme jako aktivní. V programu nalezneme všechna zranitelná místa a ošetříme je podmínkami. Jako učebnicový příklad se zpravidla používá dělení nulou. Představme si program, který používá třídu Matematika, která má metodu podil(). Třída by mohla vypadat např. takto:

class Matematika
{

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

        ...
}

Když nyní třídu použijeme takovýmto způsobem:

System.out.println("Zadejte dělitele a dělence k výpočtu podílu:");
int a = Integer.parseInt(sc.nextLine());
int b = Integer.parseInt(sc.nextLine());
System.out.println(Matematika.podil(a, b));

Pokud nyní programu uživatel zadá čísla 12 a 0, program spadne s chybou, protože nulou nelze dělit. Aktivně chybu ošetříme jednoduchou podmínkou v programu:

System.out.println("Zadejte dělitele a dělence k výpočtu podílu:");
int a = Integer.parseInt(sc.nextLine());
int b = Integer.parseInt(sc.nextLine());
if (b != 0)
        System.out.println(Matematika.podil(a, b));
else
        System.out.println("Nulou nelze dělit.");

Nyní si musíme při každém použití metody tedy hlídat, jestli do druhého parametru nevkládáme nulu. Představte si, že by metoda brala parametrů 10 a používali jsme ji v programu několikrát. Určitě je velmi složité takto ošetřovat všechny vstupy ve všech případech.

Řešením by mohlo být vložit kontrolu přímo do metody. Máme tu však nový problém: Jakou hodnotu vrátíme, když bude 2. parametr nulový? Potřebujeme hodnotu, ze které poznáme, že výpočet neproběhl korektně. To je však problém, když zvolíme např. nulu, nepoznáme, zda 0/12 je chybný výpočet či nikoli. Nevíme, zda 0 značí výsledek nebo chybu. Ani zápornými čísly si nepomůžeme. Mohli bychom použít nullovatelný typ Integer, ale jde to i jednodušeji a správněji. Parsování hodnot je 2. klasický příklad zranitelného vstupu od uživatele. Další jsou souborové operace, kde soubor nemusí existovat, nemusíme na něj mít práva, může s ním být zrovna pracováno a podobně.

Pasivní ošetření chyb

Když je operace složitější a bylo by příliš náročné ošetřovat všechny možné chybové stavy, nastupují výjimky, tzv. pasivní ošetření chyb. Nás totiž vůbec nemusí zajímat vnitřní logika v metodě, kterou voláme. Pokusíme se nebezpečnou část kódu spustit v "chráněném režimu". Tento režim je nepatrně pomalejší a liší se tím, že pokud dojde k chybě, máme možnost ji odchytit a zabránit pádu programu. O chybě zde hovoříme jako o výjimce. Využíváme k tomu tzv. try-catch bloky:

try
{
}
catch (Exception e)
{
}

Do bloku try umístíme nebezpečnou část kódu. Pokud nastane v bloku try chyba, jeho vykonávání se přeruší a program přejde do bloku catch. Pokud vše proběhne v pořádku, try se vykoná celý a catch se přeskočí. Vyzkoušejme si situaci na našem předchozím příkladu:

try
{
        System.out.println(Matematika.podil(a, b));
}
catch (Exception e)
{
        System.out.println("Při dělení nastala chyba.");
}

Kód je jednodušší v tom, že nemusíme ošetřovat všechna zranitelná místa a přemýšlet, co vše by se mohlo pokazit. Nebezpečný kód pouze obalíme blokem try a všechny chyby se zachytí v catch. Samozřejmě do try-catch bloku umístíme jen to nezbytně nutné, ne celý program :)

Nyní tedy již víme, jak ošetřit situace, kdy uživatel zadává nějaký vstup, který by mohl vyvolat chybu. Nemusí se jednat jen o souborové operace, výjimky mají velmi širokou oblast použití. Dokážeme náš program napsat tak, aby se nedal jednoduše uživatelem shodit.

V minulosti jsme již bloky try a catch použili několikrát, bylo to zejména u parsování data a času.

Použití výjimek při práci se soubory

Jak již bylo řečeno, souborové operace mohou vyvolat mnoho výjimek, proto se soubory vždy pracujeme v try-catch bloku. Existuje také několik dalších konstrukcí, které při výjimkách můžeme využívat.

Finally

Do try-catch bloku můžeme přidat ještě 3. blok a to finally. Ten se spustí vždy ať k výjimce došlo či nikoli. Představte si následující metodu pro uložení nastavení. Metody pro obsluhu souboru budou smyšlené:

public void ulozNastaveni()
{
        try
        {
                otevriSoubor("soubor.dat");
                zapisDoSouboru(nastaveni);
        }
        catch (Exception e)
        {
                System.out.println("Chyba při zápisu do souboru.");
        }
        if (souborJeOtevreny())
                zavriSoubor();
}

Metoda se soubor pokusí otevřít a zapsat do něj objekt nastavení. Při chybě vypíše hlášku do konzole. Otevřený soubor musíme opět uzavřít. Vypisovat chyby přímo v metodě je však ošklivé, to ostatně již víme, metody a objekty obecně by měly provádět jen logiku a komunikaci s uživatelem obstarává ten, kdo je volá. Dejme tedy metodě návratovou hodnotu boolean a vracejme true/false podle toho, zda se operace povedla či nikoli:

public boolean ulozNastaveni()
{
        try
        {
                otevriSoubor();
                zapisDoSouboru();
                return true;
        }
        catch (Exception e)
        {
                return false;
        }
        if (souborJeOtevreny())
                zavriSoubor();
}

Na první pohled to vypadá, že se soubor vždy uzavře. Celý kód je však v nějaké metodě, ve které voláme return. Jak víme, return ukončí metodu a nic za ním se již neprovede.

Soubor by zde vždy zůstal otevřený a uzavření by se již neprovedlo. Jako následek by to mohlo mít, že by byl poté soubor nepřístupný. Pokud vložíme zavření souboru do bloku finally, vykoná se vždy. Java si pamatuje, že blok try-catch obsahoval finally a po opuštění sekce catch zavolá finally:

public boolean ulozNastaveni()
{
        try
        {
                otevriSoubor();
                zapisDoSouboru();
                return true;
        }
        catch (Exception e)
        {
                return false;
        }
        finally
        {
                if (souborJeOtevreny())
                        zavriSoubor();
        }
}

Finally se tedy používá u výjimek na úklidové práce, dochází zde k zavírání souborů, uvolňování paměti a podobně.

Pro každý typ souborů poskytuje Java třídu zapisovače a čteče (writer a reader). Metoda pro uložení např. nastavení by v Javě reálně vypadala asi takto:

public boolean ulozNastaveni()
{
        ZapisovacSouboru z = null;
        try
        {
                z = new ZapisovacSouboru("soubor.dat");
                z.zapis(objekt);
                return true;
        }
        catch (Exception e)
        {
                return false;
        }
        finally
        {
                if (z != null)
                        z.zavri();
        }
}

Takto se opravdu reálně se soubory pracuje, pouze třídu jsem si vymyslel. Do instance zapisovače umístíme nejprve null. Poté, již v bloku try, zkusíme vytvořit zapisovač na souboru soubor.dat a zapsat nějaký objekt. Pokud se vše povede, vrátíme true (samozřejmě se poté ještě zavolá blok finally). Operace může selhat ze dvou důvodů. Buď se do souboru nepovede zapsat nebo se nám soubor pro zápis ani nepovede otevřít. Výjimku v každém případě zachytíme a vrátíme false, z čeho se poté pozná, že se metodě uložení nepodařilo. Blok finally zavře soubor, který zapisovač otevřel. Jelikož se ale otevření nemuselo povést, musíme se nejprve podívat, zda se zapisovač vůbec vytvořil, abychom měli co zavírat. Metodu bychom volali např. takto:

if (!ulozNastaveni())
        System.out.println("Nepodařilo se uložit nastavení.");

Blok catch můžeme vynechat a nechat metodu, aby výjimku klidně vyvolala. Budeme počítat s tím, že se s výjimkou vypořádá ten, kdo metodu zavolal, nikoli metoda sama. Je to tak lepší, ušetříme návratovou hodnotu metody (kterou lze poté použít pro něco jiného) a kód se nám zjednoduší:

public void ulozNastaveni() throws Exception
{
        ZapisovacSouboru z = null;
        try
        {
                z = new ZapisovacSouboru("soubor.dat");
                z.zapis(objekt);
        }
        finally
        {
                if (z != null)
                        z.zavri();
        }
}

Všimněte si, že jsme k hlavičce metody přidali throws Exception. Tím Javě říkáme, že vyvolává výjimku a díky tomu nám přestane hubovat za chybějící catch blok. Metodu bychom nyní volali takto:

try
{
        ulozNastaveni();
}
catch (Exception e)
{
        System.out.println("Nepodařilo se uložit nastavení.");
}

Nyní si ukážeme, jak celou situaci ještě více zjednodušit. Použijeme konstrukci try-with-resources.

Try-with-resources

Java (od verze 7) umožňuje značně zjednodušit práci s instancemi tříd ke čtení a zápisu do souborů. Výše uvedený blok můžeme zapsat pomocí notace try-with-resources, která nahrazuje bloky try a finally. Obrovskou výhodou je, že blok finally Java vygeneruje sama a sama zajistí, aby daná instance readeru nebo writeru soubor uzavřela. Metoda ulozNastaveni() by tedy vypadala s pomocí try-with-resources takto:

public void ulozNastaveni() throws Exception
{
        try (ZapisovacSouboru z = new ZapisovacSouboru("soubor.dat"))
        {
                z.zapis(objekt);
        }
}

Vidíme, že se kód extrémně zjednodušil, i když dělá v podstatě to samé. Při volání metody opět použijeme try-catch blok. Nezapomeňte, že try-with-resources nahrazuje pouze try-finally, nikoli catch!. Metodu, ve které se použivá try-with-resources, musíme stejně volat v try-catch bloku.

Nyní jsme dospěli přesně tam, kam jsem chtěl. K veškerým manipulacím se soubory totiž budeme v následujících tutoriálech používat konstrukci try-with-resources. Kód bude jednodušší a nikdy se nám nestane, že bychom soubor zapomněli zavřít.

K výjimkám se ještě jednou vrátíme, ukážeme si, jak odchytávat jen některé typy výjimek, které hotové třídy výjimek můžeme v našich programech používat a také, jak vytvořit výjimku vlastní. Teď jsem však chtěl vysvětlit jen potřebné minimum pro práci se soubory a ne vám zbytečně plést hlavu složitými konstrukcemi :)

Příště se podíváme, jak to funguje s právy k zápisu do souborů v systému Windows a vyzkoušíme si několik prvních souborových operací.


 

  Aktivity (1)

Článek pro vás napsal David Čápka
Avatar
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.

Jak se ti líbí článek?
Celkem (5 hlasů) :
4.44.44.44.4 4.4


 


Miniatura
Všechny články v sekci
Práce se soubory v Javě
Miniatura
Následující článek
Úvod do práce se soubory v Javě

 

 

Komentáře
Zobrazit starší komentáře (1)

Avatar
David Čápka
Tým ITnetwork
Avatar
David Čápka:

Přesně tak :)

Odpovědět 6.5.2013 13:56
Miluji svou práci a zdejší komunitu, baví mě se rozvíjet, děkuji každému členovi za to, že zde působí.
Avatar
Kit
Redaktor
Avatar
Kit:

Do try-with-resources můžeš přece přidat i catch. Nemusíš ho obalovat dalším blokem, pokud nechceš.

public void ulozNastaveni() {
    try (ZapisovacSouboru z = new ZapisovacSouboru("soubor.dat")) {
        z.zapis(objekt);
    } catch (IOException e) {
        System.err.println("Nepodařilo se uložit nastavení.");
    }
}

Vytknul bych i zápis chyb do System.out místo do System.err. Chybová hlášení nepatří do datového výstupu.

Odpovědět  +1 7.5.2013 11:01
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
Kit
Redaktor
Avatar
Kit:

Ten příklad pro Javu < 7 bych upravil takto:

boolean ulozNastaveni() {
    ZapisovacSouboru z = null;
    try {
        z = new ZapisovacSouboru("soubor.dat");
        z.zapis(objekt);
        return true;
    } catch (IOException e) {
        System.err.println("Chyba při otevírání souboru");
        return false;
    } finally {
        if (z != null)
            try {
                z.close();
            } catch (IOException ex) {
                System.err.println("Chyba při zavírání souboru");
            }
    }
}

Jinak kompilátor řve při zavírání souboru. Tedy pokud to nemáš ošetřeno už v metodě zavři().

Odpovědět 7.5.2013 11:18
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
David Čápka
Tým ITnetwork
Avatar
Odpovědět 7.5.2013 11:20
Miluji svou práci a zdejší komunitu, baví mě se rozvíjet, děkuji každému členovi za to, že zde působí.
Avatar
Paul
Člen
Avatar
Paul:

Existuje již pokračování výjimek v Javě? V tomhle díle je zmiňované ale nikde jsem ho nenašel, díky.

 
Odpovědět 30.1.2014 14:20
Avatar
Matěj Kripner
Redaktor
Avatar
Matěj Kripner:

Je tu psáno, že blok finally se vykoná vždy, i pokud již došlo k vrácení hodnoty příkazem return. Čistě teoreticky, co by se stalo, kdyby byl v bloku finally další příkaz return? Díky.

Odpovědět  +1 3.8.2014 16:40
"We reject kings, presidents and voting. We believe in rough consensus and running code" David Clark
Avatar
coells
Redaktor
Avatar
Odpovídá na Matěj Kripner
coells:

Zkus se zamyslet nad daleko zajímavější (a praktickou) otázkou - co když catch neošetří výjimku, případně provede re-throw, ale ve finally bloku je explicitní return nebo dokonce finally blok způsobí nezávislou výjimku?

 
Odpovědět  +1 3.8.2014 19:22
Avatar
Matěj Kripner
Redaktor
Avatar
Odpovídá na coells
Matěj Kripner:

Pochybuju, že se blok finally provede opravdu vždy. Co když je vyvolaná výjimka tak závažná, že nelze v programu dále pokračovat.

Odpovědět 3.8.2014 19:59
"We reject kings, presidents and voting. We believe in rough consensus and running code" David Clark
Avatar
coells
Redaktor
Avatar
Odpovídá na Matěj Kripner
coells:

Finally blok garantuje provedení instrukcí do té míry, že pokud neprojde finally, neprojde ani další intrukce, která za ním následuje. To je ta lepší varianta, například:

try
{
  System.Exit(0);
}
finally
{
   System.out.println();
}

Ta horší varianta je, že je výjimka tak závažná, že pokus o provedení finally bloku vyvolá další výjimku, která zakryje tu původní.

 
Odpovědět  +2 3.8.2014 22:01
Avatar
Roman Duchoň:

Moc nejde příkaz s dělením...
a / 0 => Infinity
0 / 0 => NaN
To jen tak pro aktualizaci. Předpokládám, že to odladili.

Odpovědět 26. října 13:17
RD
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 11. Zobrazit vše