home Productietechnologie Fabricage-apparatuur
Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Industrial programming >> Java

Java - Uitzonderingen

Een uitzondering (of uitzonderlijke gebeurtenis) is een probleem dat zich voordoet tijdens de uitvoering van een programma. Wanneer een Uitzondering optreedt, wordt de normale stroom van het programma onderbroken en wordt het programma/de toepassing abnormaal beëindigd, wat niet wordt aanbevolen, daarom moeten deze uitzonderingen worden afgehandeld.

Een uitzondering kan om veel verschillende redenen optreden. Hieronder volgen enkele scenario's waarin zich een uitzondering voordoet.

  • Een gebruiker heeft ongeldige gegevens ingevoerd.

  • Een bestand dat moet worden geopend, kan niet worden gevonden.

  • Een netwerkverbinding is verbroken tijdens de communicatie of de JVM heeft onvoldoende geheugen.

Sommige van deze uitzonderingen worden veroorzaakt door een gebruikersfout, andere door een programmeerfout en andere door fysieke bronnen die op de een of andere manier hebben gefaald.

Op basis hiervan hebben we drie categorieën Uitzonderingen. U moet ze begrijpen om te weten hoe het afhandelen van uitzonderingen in Java werkt.

  • Aangevinkte uitzonderingen − Een gecontroleerde uitzondering is een uitzondering die tijdens compilatie door de compiler wordt gecontroleerd (aangekondigd), deze worden ook wel uitzonderingen tijdens compilatie genoemd. Deze uitzonderingen kunnen niet zomaar worden genegeerd, de programmeur moet deze uitzonderingen regelen (afhandelen).

Als u bijvoorbeeld FileReader . gebruikt class in uw programma om gegevens uit een bestand te lezen, als het bestand gespecificeerd in de constructor niet bestaat, dan een FileNotFoundException optreedt, en de compiler vraagt ​​de programmeur om de uitzondering af te handelen.

Voorbeeld

Live demo
import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

   public static void main(String args[]) {		
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file); 
   }
}

Als u het bovenstaande programma probeert te compileren, krijgt u de volgende uitzonderingen.

Uitvoer

C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(file);
                      ^
1 error

Opmerking − Sinds de methoden read() en close() van de FileReader-klasse IOException gooit, kunt u zien dat de compiler een melding geeft om IOException af te handelen, samen met FileNotFoundException.

  • Niet-aangevinkte uitzonderingen − Een ongecontroleerde uitzondering is een uitzondering die optreedt op het moment van uitvoering. Deze worden ook wel Runtime Exceptions genoemd . Deze omvatten programmeerfouten, zoals logische fouten of oneigenlijk gebruik van een API. Runtime-uitzonderingen worden genegeerd op het moment van compilatie.

Als u bijvoorbeeld een array van grootte 5 in uw programma hebt gedeclareerd en probeert de 6 de element van de array en vervolgens een ArrayIndexOutOfBoundsExceptionexception gebeurt.

Voorbeeld

Live demo
public class Unchecked_Demo {
   
   public static void main(String args[]) {
      int num[] = {1, 2, 3, 4};
      System.out.println(num[5]);
   }
}

Als u het bovenstaande programma compileert en uitvoert, krijgt u de volgende uitzondering.

Uitvoer

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)

  • Fouten − Dit zijn helemaal geen uitzonderingen, maar problemen die zich voordoen buiten de controle van de gebruiker of de programmeur. Fouten worden doorgaans genegeerd in uw code, omdat u zelden iets aan een fout kunt doen. Als er bijvoorbeeld een stack overflow optreedt, zal er een fout optreden. Ze worden ook genegeerd op het moment van compilatie.

Uitzonderingshiërarchie

Alle uitzonderingsklassen zijn subtypen van de klasse java.lang.Exception. De uitzonderingsklasse is een subklasse van de klasse Throwable. Behalve de uitzonderingsklasse is er nog een andere subklasse genaamd Error, die is afgeleid van de Throwable-klasse.

Fouten zijn abnormale omstandigheden die optreden in geval van ernstige storingen, deze worden niet afgehandeld door de Java-programma's. Fouten worden gegenereerd om fouten aan te geven die zijn gegenereerd door de runtime-omgeving. Voorbeeld:JVM heeft onvoldoende geheugen. Normaal gesproken kunnen programma's niet herstellen van fouten.

De Exception-klasse heeft twee hoofdsubklassen:IOException-klasse en RuntimeException-klasse.

Hieronder volgt een lijst met de meest voorkomende aangevinkte en niet-aangevinkte Java's ingebouwde uitzonderingen.

Uitzonderingsmethoden

Hieronder volgt de lijst met belangrijke methoden die beschikbaar zijn in de Throwable-klasse.

Zr.nr. Methode en beschrijving
1

public String getMessage()

Retourneert een gedetailleerd bericht over de uitzondering die is opgetreden. Dit bericht wordt geïnitialiseerd in de Throwable-constructor.
2

openbare Throwable getCause()

Retourneert de oorzaak van de uitzondering zoals weergegeven door een Throwable-object.
3

public String toString()

Retourneert de naam van de klasse samengevoegd met het resultaat van getMessage().
4

public void printStackTrace()

Drukt het resultaat van toString() samen met de stacktracering af naar System.err, de foutuitvoerstroom.
5

public StackTraceElement [] getStackTrace()

Retourneert een array met elk element op de stacktracering. Het element op index 0 vertegenwoordigt de bovenkant van de call-stack en het laatste element in de array vertegenwoordigt de methode onderaan de call-stack.
6

openbare Throwable fillInStackTrace()

Vult de stacktracering van dit Throwable-object met de huidige stacktracering en voegt eerdere informatie in de stacktrace toe.

Uitzonderingen opvangen

Een methode vangt een uitzondering met een combinatie van de try en vang trefwoorden. Om de code wordt een try/catch-blok geplaatst dat een uitzondering zou kunnen genereren. Code binnen een try/catch-blok wordt beschermde code genoemd en de syntaxis voor het gebruik van try/catch ziet er als volgt uit −

Syntaxis

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

De code die vatbaar is voor uitzonderingen wordt in het try-blok geplaatst. Wanneer een uitzondering optreedt, wordt die uitzondering afgehandeld door het bijbehorende catch-blok. Elk try-blok moet onmiddellijk worden gevolgd door een catch-blok of door een blokkering.

Een catch-statement houdt in dat u het type uitzondering aangeeft dat u probeert te vangen. Als er een uitzondering optreedt in beveiligde code, wordt het catch-blok (of blokken) dat volgt op de try gecontroleerd. Als het type uitzondering dat is opgetreden in een catch-blok wordt vermeld, wordt de uitzondering doorgegeven aan het catch-blok, net zoals een argument wordt doorgegeven aan een methodeparameter.

Voorbeeld

Het volgende is een array gedeclareerd met 2 elementen. Vervolgens probeert de code toegang te krijgen tot de 3 de element van de array dat een uitzondering genereert.

Live demo
// File Name : ExcepTest.java
import java.io.*;

public class ExcepTest {

   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Meerdere vangblokken

Een try-blok kan worden gevolgd door meerdere catch-blokken. De syntaxis voor meerdere catch-blokken ziet er als volgt uit −

Syntaxis

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}

De vorige uitspraken demonstreren drie catch-blokken, maar je kunt er een willekeurig aantal hebben na een enkele poging. Als er een uitzondering optreedt in de beveiligde code, wordt de uitzondering gegooid naar het eerste catch-blok in de lijst. Als het gegevenstype van de gegenereerde uitzondering overeenkomt met ExceptionType1, wordt het daar gevangen. Zo niet, dan gaat de uitzondering naar de tweede catch-statement. Dit gaat door totdat de uitzondering wordt opgevangen of door alle vangsten valt, in welk geval de huidige methode de uitvoering stopt en de uitzondering wordt teruggeworpen naar de vorige methode op de aanroepstack.

Voorbeeld

Hier is een codesegment dat laat zien hoe je meerdere try/catch-statements kunt gebruiken.

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
} catch (IOException i) {
   i.printStackTrace();
   return -1;
} catch (FileNotFoundException f) // Not valid! {
   f.printStackTrace();
   return -1;
}

Meerdere soorten uitzonderingen opvangen

Sinds Java 7 kun je meer dan één uitzondering afhandelen met een enkel catch-blok, deze functie vereenvoudigt de code. Hier is hoe je het zou doen −

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

De worpen/worp trefwoorden

Als een methode een gecontroleerde uitzondering niet afhandelt, moet de methode deze declareren met de throws trefwoord. Het trefwoord throws verschijnt aan het einde van de handtekening van een methode.

Je kunt een exception gooien, ofwel een nieuw geïnstantieerde ofwel een exception die je zojuist hebt opgevangen, door de throw te gebruiken zoekwoord.

Probeer het verschil te begrijpen tussen worpen en worp trefwoorden, worpen wordt gebruikt om de afhandeling van een aangevinkte uitzondering uit te stellen en gooi wordt gebruikt om expliciet een uitzondering aan te roepen.

De volgende methode verklaart dat het een RemoteException genereert −

Voorbeeld

import java.io.*;
public class className {

   public void deposit(double amount) throws RemoteException {
      // Method implementation
      throw new RemoteException();
   }
   // Remainder of class definition
}

Een methode kan declareren dat het meer dan één uitzondering genereert, in welk geval de uitzonderingen worden gedeclareerd in een lijst gescheiden door komma's. De volgende methode declareert bijvoorbeeld dat er een RemoteException en een InsufficientFundsException worden gegenereerd −

Voorbeeld

import java.io.*;
public class className {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Method implementation
   }
   // Remainder of class definition
}

Het laatste blok

Het laatste blok volgt op een try-blok of een catch-blok. Een definitief codeblok wordt altijd uitgevoerd, ongeacht het optreden van een uitzondering.

Als u een definitief blok gebruikt, kunt u alle opschoningsinstructies uitvoeren die u wilt uitvoeren, ongeacht wat er in de beschermde code gebeurt.

Een definitief blok verschijnt aan het einde van de catch-blokken en heeft de volgende syntaxis −

Syntaxis

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}finally {
   // The finally block always executes.
}

Voorbeeld

Live demo
public class ExcepTest {

   public static void main(String args[]) {
      int a[] = new int[2];
      try {
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }finally {
         a[0] = 6;
         System.out.println("First element value: " + a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Let op het volgende −

  • Een catch-clausule kan niet bestaan ​​zonder een try-statement.

  • Het is niet verplicht om finaal-clausules te hebben wanneer een try/catch-blok aanwezig is.

  • Het try-blok kan niet aanwezig zijn zonder de catch-clausule of de final-clausule.

  • Er mag geen code aanwezig zijn tussen de try, catch, final-blokken.

De try-with-resources

Over het algemeen moeten we, wanneer we bronnen zoals streams, verbindingen, enz. gebruiken, deze expliciet sluiten met behulp van eindelijk block. In het volgende programma lezen we gegevens uit een bestand met behulp van FileReader en we sluiten het met eindelijk blok.

Voorbeeld

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File file = new File("file.txt");
         fr = new FileReader(file); char [] a = new char[50];
         fr.read(a);   // reads the content to the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         try {
            fr.close();
         } catch (IOException ex) {		
            ex.printStackTrace();
         }
      }
   }
}

proberen-met-bronnen , ook wel automatisch resourcebeheer genoemd , is een nieuw mechanisme voor het afhandelen van uitzonderingen dat is geïntroduceerd in Java 7 en dat automatisch de bronnen sluit die worden gebruikt in het try-catch-blok.

Om deze verklaring te gebruiken, hoeft u alleen de vereiste bronnen tussen haakjes aan te geven en de aangemaakte bron wordt automatisch gesloten aan het einde van het blok. Hieronder volgt de syntaxis van de instructie try-with-resources.

Syntaxis

try(FileReader fr = new FileReader("file path")) {
   // use the resource
   } catch () {
      // body of catch 
   }
}

Hieronder volgt het programma dat de gegevens in een bestand leest met behulp van de instructie try-with-resources.

Voorbeeld

import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://file.txt")) {
         char [] a = new char[50];
         fr.read(a);   // reads the contentto the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Houd rekening met de volgende punten bij het werken met de instructie try-with-resources.

  • Om een ​​klasse te gebruiken met de instructie try-with-resources, moet deze AutoCloseable . implementeren interface en de close() methode ervan wordt automatisch aangeroepen tijdens runtime.

  • U kunt meer dan één klasse declareren in de instructie try-with-resources.

  • Terwijl u meerdere klassen declareert in het try-blok van de instructie try-with-resources, worden deze klassen in omgekeerde volgorde gesloten.

  • Behalve de declaratie van middelen tussen haakjes is alles hetzelfde als een normaal try/catch-blok van een try-blok.

  • De resource gedeclareerd in try wordt geïnstantieerd net voor het begin van de try-block.

  • De resource die bij het try-blok is gedeclareerd, wordt impliciet als definitief verklaard.

Door de gebruiker gedefinieerde uitzonderingen

U kunt uw eigen uitzonderingen maken in Java. Houd de volgende punten in gedachten bij het schrijven van uw eigen uitzonderingsklassen −

  • Alle uitzonderingen moeten een kind zijn van Throwable.

  • Als u een gecontroleerde uitzondering wilt schrijven die automatisch wordt afgedwongen door de Handle or Declare Rule, moet u de Exception-klasse uitbreiden.

  • Als u een runtime-uitzondering wilt schrijven, moet u de klasse RuntimeException uitbreiden.

We kunnen onze eigen uitzonderingsklasse definiëren zoals hieronder −

class MyException extends Exception {
}

U hoeft alleen de vooraf gedefinieerde Uitzondering . uit te breiden class om uw eigen Exception te maken. Deze worden beschouwd als gecontroleerde uitzonderingen. De volgende InsufficientFundsException class is een door de gebruiker gedefinieerde uitzondering die de klasse Exception uitbreidt, waardoor het een gecontroleerde uitzondering wordt. Een uitzonderingsklasse is net als elke andere klasse en bevat nuttige velden en methoden.

Voorbeeld

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

Om het gebruik van onze door de gebruiker gedefinieerde uitzondering te demonstreren, bevat de volgende klasse CheckingAccount een methode draw() die een InsufficientFundsException genereert.

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount {
   private double balance;
   private int number;
   
   public CheckingAccount(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

Het volgende BankDemo-programma demonstreert het aanroepen van de storting() en opname() methoden van CheckingAccount.

// File Name BankDemo.java
public class BankDemo {

   public static void main(String [] args) {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      
      try {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      } catch (InsufficientFundsException e) {
         System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

Compileer alle bovenstaande drie bestanden en voer BankDemo uit. Dit levert het volgende resultaat op −

Uitvoer

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
         at CheckingAccount.withdraw(CheckingAccount.java:25)
         at BankDemo.main(BankDemo.java:13)

Veelvoorkomende uitzonderingen

In Java is het mogelijk om twee categorieën uitzonderingen en fouten te definiëren.

  • JVM-uitzonderingen − Dit zijn uitzonderingen/fouten die uitsluitend of logisch worden veroorzaakt door de JVM. Voorbeelden:NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.

  • Programmatische uitzonderingen − Deze uitzonderingen worden expliciet gegenereerd door de toepassing of de API-programmeurs. Voorbeelden:IllegalArgumentException, IllegalStateException.


Java

  • C Taal
  • VHDL
  • Verilog
  • MATLAB
  • Python
  • Java
    1. Java-operators
    2. Java-opmerkingen
    3. Java voor elke lus
    4. Java-strings
    5. Java-interface
    6. Afhandeling van Java-uitzonderingen
    7. Java worp en worpen
    8. Java-vangst Meerdere uitzonderingen
    9. Java proberen-met-bronnen
    10. Java-annotaties
    11. Java-beweringen