Afhandeling Java-uitzondering

In de zelfstudie leren we over verschillende benaderingen van het afhandelen van uitzonderingen in Java met behulp van voorbeelden.

In de laatste tutorial hebben we geleerd over Java-uitzonderingen. We weten dat uitzonderingen de uitvoering van een programma abnormaal beëindigen.

Daarom is het belangrijk om met uitzonderingen om te gaan. Hier is een lijst met verschillende benaderingen om uitzonderingen in Java af te handelen.

• probeer... vangblok
• eindelijk blokkeren
• zoekwoord gooien en gooien

1. Java try...catch blok

Het try-catch-blok wordt gebruikt om uitzonderingen in Java af te handelen. Hier is de syntaxis van try...catch blok:

try {
  // code
}
catch(Exception e) {
  // code
}

Hier hebben we de code geplaatst die een uitzondering zou kunnen genereren in de try blok. Elke try blok wordt gevolgd door een catch blok.

Wanneer er een uitzondering optreedt, wordt deze opgevangen door de catch blok. De catch blok kan niet worden gebruikt zonder de try blok.

Voorbeeld:afhandeling van uitzonderingen met try...catch

class Main {
  public static void main(String[] args) {

    try {

      // code that generate exception
      int divideByZero = 5 / 0;
      System.out.println("Rest of code in try block");
    }
    
    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
  }
}

Uitvoer

ArithmeticException => / by zero

In het voorbeeld proberen we een getal te delen door 0 . Hier genereert deze code een uitzondering.

Om de uitzondering af te handelen, hebben we de code, 5 / 0 binnen de try blok. Als er nu een uitzondering optreedt, wordt de rest van de code binnen de try blok wordt overgeslagen.

De catch block vangt de uitzondering op en instructies in het catch-blok worden uitgevoerd.

Als geen van de instructies in de try blok genereert een uitzondering, de catch blok wordt overgeslagen.

2. Java eindelijk blokkeren

In Java is de finally blok wordt altijd uitgevoerd, ongeacht of er een uitzondering is of niet.

De finally blok is optioneel. En voor elke try blok, er kan maar één finally . zijn blok.

De basissyntaxis van finally blok is:

try {
  //code
}
catch (ExceptionType1 e1) { 
  // catch block
}
finally {
  // finally block always executes
}

Als er een uitzondering optreedt, wordt de finally blok wordt uitgevoerd na de try...catch blok. Anders wordt het uitgevoerd na het try-blok. Voor elke try blok, kan er maar één finally . zijn blok.

Voorbeeld:afhandelen van Java-uitzonderingen met gebruik van definitief blok

class Main {
  public static void main(String[] args) {
    try {
      // code that generates exception
      int divideByZero = 5 / 0;
    }

    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
    
    finally {
      System.out.println("This is the finally block");
    }
  }
}

Uitvoer

ArithmeticException => / by zero
This is the finally block

In het bovenstaande voorbeeld delen we een getal door 0 binnen de try blok. Hier genereert deze code een ArithmeticException .

De uitzondering wordt opgevangen door de catch blok. En dan de finally blok wordt uitgevoerd.

Opmerking :Het is een goede gewoonte om de finally . te gebruiken blok. Het is omdat het belangrijke opschoningscodes kan bevatten, zoals,

• code die per ongeluk per ongeluk kan worden overgeslagen, doorgaan of breken
• een bestand of verbinding sluiten

3. Java throw en throws trefwoord

De Java throw trefwoord wordt gebruikt om expliciet een enkele uitzondering te genereren.

Wanneer we throw een uitzondering, de stroom van het programma gaat van de try blok naar de catch blok.

Voorbeeld:afhandeling van uitzonderingen met Java-throw

class Main {
  public static void divideByZero() {

    // throw an exception
    throw new ArithmeticException("Trying to divide by 0");
  }

  public static void main(String[] args) {
    divideByZero();
  }
}

Uitvoer

Exception in thread "main" java.lang.ArithmeticException: Trying to divide by 0
        at Main.divideByZero(Main.java:5)
        at Main.main(Main.java:9)

In het bovenstaande voorbeeld gooien we expliciet de ArithmeticException met behulp van de throw zoekwoord.

Evenzo is de throws sleutelwoord wordt gebruikt om het type uitzonderingen aan te geven dat binnen de methode kan voorkomen. Het wordt gebruikt in de methodedeclaratie.

Voorbeeld:Java gooit trefwoord

import java.io.*;

class Main {
  // declareing the type of exception
  public static void findFile() throws IOException {

    // code that may generate IOException
    File newFile = new File("test.txt");
    FileInputStream stream = new FileInputStream(newFile);
  }

  public static void main(String[] args) {
    try {
      findFile();
    }
    catch (IOException e) {
      System.out.println(e);
    }
  }
}

Uitvoer

java.io.FileNotFoundException: test.txt (The system cannot find the file specified)

Als we dit programma uitvoeren en het bestand test.txt bestaat niet, FileInputStream gooit een FileNotFoundException die de IOException . verlengt klasse.

De findFile() methode specificeert dat een IOException kan worden gegooid. De main() methode roept deze methode aan en handelt de uitzondering af als deze wordt gegenereerd.

Als een methode geen exceptions afhandelt, moet het type exceptions dat erin kan voorkomen worden gespecificeerd in de throws clausule.

Ga voor meer informatie naar Java worpen en worpen.