Indførelse af undtagelser

"Hej, Amigo. Vi skal have en meget interessant lektion i dag. Jeg vil fortælle dig om undtagelser. Undtagelser er en speciel mekanisme, der lader os håndtere fejl i programmet. Her er nogle eksempler på fejl, der kan opstå i et program:

1. Programmet forsøger muligvis at skrive en fil, når harddisken er helt fuld.

2. Programmet kan forsøge at kalde en metode på en variabel, der lagrer en nul-reference.

3. Programmet kan forsøge at dividere et tal med 0."

Alle disse handlinger resulterer i fejl. Normalt er resultatet, at programmet afsluttes øjeblikkeligt, da det ikke giver nogen mening at fortsætte med at udføre kode i dette tilfælde.

"Hvorfor?"

"Giver det mening at blive ved med at dreje et hjul, hvis bilen er kørt af vejen og falder ned fra en klippe?"

"Skal programmet stoppe med at køre, så?"

"Ja. Det er i hvert fald, hvad der plejede at ske. Enhver fejl fik programmet til at afslutte."

"Det er en meget smart tilgang."

"Men ville det ikke være bedre at prøve og fortsætte med at køre programmet?"

"Ja. Antag, at du har skrevet en enorm mængde tekst i Word og gemt den. Hvad nu, hvis gemmeoperationen mislykkes, men programmet får dig til at tro, at alt er i orden? Og du fortsætter med at skrive. Det ville være dumt, ikke det?"

"Ja."

"Så kom programmører med en interessant løsning: hver funktion ville returnere status for sit arbejde. 0 betød, at den fungerede som forventet. Enhver anden værdi ville betyde, at der opstod en fejl, og returværdien var en fejlkode."

"Den tilgang har dog også sine mangler. Efter hvert (!) funktionskald skal du tjekke returkoden (nummeret). Først og fremmest er dette ubelejligt: ​​fejlhåndteringskoden udføres sjældent, men skal medtages overalt. For det andet returnerer funktioner ofte forskellige værdier – hvad skal du med dem?"

"Godt. Det tænkte jeg også på."

"Så ankom en lys fremtid i form af undtagelser og en fejlhåndteringsmekanisme. Sådan fungerer det:

1. Når der opstår en fejl, opretter Java-maskinen et særligt objekt – en undtagelse – hvor den gemmer al fejlinformation. Der er forskellige undtagelser for forskellige fejl.

2. En undtagelse får programmet til straks at afslutte den aktuelle funktion, og den næste funktion, og så videre – indtil det afslutter hovedmetoden. Så afsluttes programmet. Programmører kan også sige, at Java-maskinen 'afvikler opkaldsstakken'."

"Men du sagde, at programmet ikke altid afsluttes."

"Ja, for der er en måde at fange en undtagelse på. Vi kan skrive speciel kode på det rigtige sted for at fange de undtagelser, vi holder af, og for at gøre noget med dem. Det er vigtige ting."

"For at hjælpe os med dette er der en særlig try-catch- konstruktion. Sådan fungerer det:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (Exception e)
        {
           System.out.println("Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

Program starts
Before method1 calling
Exception has been caught
Program is still running

"Men hvorfor vil 'After calling method1. This will never be vist' ikke blive vist på skærmen?"

"Jeg er glad for, at du spurgte. I linje 25 dividerer vi med 0, hvilket fører til en fejl – en undtagelse. Java-maskinen opretter et ArithmeticException- objekt med information om fejlen. Objektet er undtagelsen."

"Undtagelsen forekommer inde i method1metoden. Dette får metoden til at afslutte med det samme. Det ville få hovedmetoden til at afslutte, hvis ikke for try-catch- blokken."

"Hvis der opstår en undtagelse inde i en try- blok, fanges den i catch- blokken. Resten af ​​koden i try-blokken vil ikke blive eksekveret. I stedet vil catch- blokken begynde at blive eksekveret. "

"Jeg forstår det ikke."

"Med andre ord fungerer koden sådan her:

1. Hvis der opstår en undtagelse i en try- blok, ophører koden med at blive eksekveret, hvor undtagelsen opstod, og catch- blokken begynder at blive eksekveret.

2. Hvis der ikke forekommer nogen undtagelse, udføres try-blokken til slutningen , og catch- blokken udføres ikke. "

"Hva?"

"Forestil dig, at vi efter hvert metodekald kontrollerer, om metoden returnerede normalt eller blev brat afsluttet som følge af en undtagelse. Hvis der er en undtagelse, så flytter vi til at udføre catch-blokken (hvis der er en) for at fange undtagelsen. Hvis der ikke er nogen catch-blok, afslutter vi den nuværende metode, og den metode, der kaldte os, udfører den samme kontrol."

"Jeg tror, ​​jeg har fået det nu."

"Fremragende."

"Hvad betyder 'undtagelse' inde i fangstsætningen?"

" Alle undtagelser er klasser, der arver Exception-klassen. Vi kan fange en bestemt undtagelse ved at angive undtagelsesklassen i catch- blokken, eller vi kan fange alle undtagelser ved at angive deres fælles overordnede klasse – Exception. Så kan vi få alle de nødvendige fejl information fra variablen e (den gemmer en reference til undtagelsesobjektet)."

"Cool! Hvis der forekommer forskellige undtagelser i min metode, kan jeg så behandle dem anderledes?"

"Ikke kun kan du, men du bør. Du kan gøre det sådan her:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (NullPointerException e)
        {
           System.out.println("Null reference. Exception has been caught");
        }
        catch (ArithmeticException e)
        {
            System.out.println("Division by zero. Exception has been caught");
        }
        catch (Exception e)
        {
            System.out.println("Any other errors. Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

" Prøv- blokken kan parres med flere catch -blokke, som hver vil fange de angivne typer undtagelser."

"Jeg tror, ​​jeg forstår. Jeg kan ikke selv skrive det her endnu, men hvis jeg støder på det i kode, bliver jeg ikke bange."