===== Výjimky =====

===== MojeVyjimka.java =====
Z dokumentace ke třídě [[http://java.sun.com/javase/6/docs/api/java/lang/Exception.html|Exception]] zjistíme, že ta poskytuje 4 konstruktory. Každý může být užitečný, takže si je zařídíme také všechny.
<code java>
package vyjimky;

public class MojeVyjimka extends Exception {

    /**
     * Konstruktor bez zpravy. Muze se zdat k nicemu, nicmene
     * pokud mate chytre navrzenou hierarchii vyjimek, lze
     * to obcas zvladnout i beze slov ... :-)
     * A navic, vyjimky vetsinou potrebujete
     * selektivne zpracovavat, takze se hierarchie hodi.
     * Parsovani zprav neni moc dobry napad ...
     */
    public MojeVyjimka (){
        super();
    }

    /**
     * Konstruktor se zpravou
     * @param message zprava
     */
    public MojeVyjimka (String message){
        super(message);
    }

    /**
     * Konstruktor, kteremu muzete dat zpravu i "pricinu".
     * Pokud zpracovavate vyjimku na vice urovnich, muzete tu
     * starou "pribalit",
     * paklize chcete nutne vyhodit novou vyjimku.
     * @param message zprava
     * @param cause puvodni vyjimka
     */
    public MojeVyjimka (String message, Throwable cause){
        super(message, cause);
    }

    /**
     * Konstruktor jen s pricinou. Viz vyse.
     * @see #MojeVyjimka(java.lang.String, java.lang.Throwable)
     * @param cause puvodni vyjimka
     */
    public MojeVyjimka (Throwable cause){
        super(cause);
    }
}
</code>

===== Main.java =====
<code java>
package vyjimky;

public class Main {
    public static void c(){
        System.out.println("c");
        /*
         * hmm, deleni nulou, jak to asi dopadne ...
         * k vypisu "c-konec" se nedostaneme
         */
        int a = 1/0;
        System.out.println("c-konec");
    }

    /**
     * metoda b
     * @throws MojeVyjimka je potomkem Exception,
     * takze ji v metode musime deklarovat
     */
    public static void b() throws MojeVyjimka{
        System.out.println("b");
        try{
            c();
        }
        catch (ArithmeticException ex){
            /*
             * vyjimku chytime, vypiseme, a posleme dal
             */
            System.out.println("hlupaku: "+ ex.getMessage());
            throw ex;
        }
        finally {
            /*
             * Kod v sekci finally se provede v kazdem pripade:
             *  1. sekce try skonci normalne
             *  2. ze sekce try se utece pomoci return
             *  3. ze sekce se vyskoci vyjimkou
             *  4. ze sekce se vyskoci vyjimkou a v catch ji odchytime
             */
            System.out.println("b-konec");
        }
    }

    public static void a() throws MojeVyjimka{
        System.out.println("a");
        try {
            b();
        }
        catch (ArithmeticException ex){
            //throw new MojeVyjimka();
            //throw new MojeVyjimka(ex);
            throw new MojeVyjimka("Zachycena vyjimka", ex);
        }
        /*
         * tento kod se neprovede v pripade, ze se v sekci
         * catch zase vyhazuje vyjimka
         */

        System.out.println("a-konec");
    }

    public static void main (String [] args) throws MojeVyjimka{
        try{
            a();
        }
        /*
         * Vyjimky se musi zachytavat od tech v hierarchii
         * nejnize. Obracene by nam to ted ani nedovolil
         * prekladac.
         */
        catch (MojeVyjimka ex){
            System.out.println("nastala moje chyba: "+ex.getMessage());
            /*
             * Poslali jsme pribalenou jinou vyjimku, takze
             * stacktrace bude celkem pekny.
             * Pokud bychom ji nepribalili, tak ztratime informaci o tom
             * kde skutecne vyjimka vznikla.
             * Misto toho budeme vedet pouze, kde jsme vyhodili tu druhou.
             * Abychom se opravdu dozvedeli puvodni pricinu vyjimky,
             * je dobre:
             *   1. ji bud jen preposilat (throw ex)
             *   2. pribalovat do konstruktoru te nove, pokud nutne potrebujeme
             *      nekde zachytavat a posilat jinou.
             */
            ex.printStackTrace();
        }
        catch (ArithmeticException ex){
            System.out.println("nastala aritmeticka chyba: "+ex.getMessage());
        }
        catch (Exception ex){
            System.out.println("nastala obecna chyba: "+ex.getMessage());
        }
        System.out.println("konec");
    }
}
</code>