Undtagelseshåndtering ind Java

Hvad er en undtagelse i Java?

An Undtagelse i Java er en hændelse, der afbryder udførelsen af ​​programinstruktioner og forstyrrer den normale programudførelse. Det er et objekt, der indpakker en fejlhændelsesinformation, der opstod i en metode, og den sendes til runtime-systemet. Java, undtagelser bruges primært til at signalere forskellige typer fejltilstande, så udviklere kan reagere på dem på en kontrolleret måde.

Der er to brede kategorier af fejl i Java:

1. Kompiler tidsfejl
2. Kørselsfejl

Kompileringstidsfejl kan klassificeres i to yderligere typer:

• Syntaksfejl
• Semantiske fejl

Syntaksfejl Eksempel:

I stedet for at erklære int a; du fejlagtigt erklærede det som in a;, hvor compileren vil give en fejl.

Eksempel på semantiske fejl: Du har deklareret en variabel int a; og efter nogle linjer kode erklærer du igen et heltal som int a;. Alle disse fejl er fremhævet, når du kompilerer koden.

Eksempel på kørselsfejl

En runtime-fejl kaldes en undtagelseDet er enhver hændelse, der afbryder den normale programudførelse. Eksempler på undtagelser inkluderer aritmetisk undtagelse, NullPointerException, divider med nul-undtagelse og mange flere. Undtagelser i Java er forhold, der ofte ligger uden for en udviklers direkte kontrol.

Klik link. hvis videoen ikke er tilgængelig

Hvorfor har vi brug for undtagelseshåndtering?

Forestil dig, at du har kodet et program til at få adgang til en server. Tingene fungerer fint, mens du udviklerping koden i et lokalt miljø med kontrollerede forhold.

Under en faktisk produktionskørsel kan serveren være nede. Når dit program forsøger at få adgang til den, opstår der en undtagelse, og uden korrekt håndtering vil programmet afsluttes brat.

Sådan håndterer du en undtagelse i Java

Indtil videre har vi set, at en undtagelse ofte er uden for en udviklers kontrol. At give miljømæssige problemer skylden for kodefejl er dog ikke en reel løsning. Du har brug for robust programmering, der tager sig af exceptionelle situationer. Sådan kode er kendt som en Undtagelseshåndterer.

I vores eksempel ville god undtagelseshåndtering betyde, at når den primære server er nede, opretter programmet automatisk forbindelse til en backupserver.

For at implementere dette kan du skrive kode for at oprette forbindelse til serveren ved hjælp af traditionelle "if"- og "else"-betingelser. Du vil kontrollere, om serveren er nede, og hvis ja, vil du skrive kode for at oprette forbindelse til backupserveren. En sådan organisering af kode ved hjælp af "if"- og "else"-grene er ikke effektiv, når din kode har flere Java undtagelser at håndtere.

class connect{
	if(Server Up){
	 // code to connect to server
	}
	else{
	 // code to connect to BACKUP server
	}
}

Prøv Catch Block Java

Java tilbyder en indbygget mekanisme til håndtering af undtagelser, der adskiller normal logik fra logik til fejlretning.

1. Den normale kode går ind i en PRØV blok.
2. Undtagelseshåndteringskoden går ind i FANGST blok.

I vores eksempel vil TRY-blokken indeholde koden til at oprette forbindelse til serveren. CATCH-blokken vil indeholde koden til at oprette forbindelse til backupserveren. Hvis serveren er oppe, vil koden i CATCH-blokken blive ignoreret. Hvis serveren er nede, vil en undtagelse blive genereret, og koden i catch-blokken vil blive udført.

Så sådan håndteres en undtagelse i Java.

Syntaks for brug af try og catch

try{
    statement(s)
}
catch (exceptiontype name){
	statement(s)
}

Eksempel på en "Try Catch"-blok

Trin 1) Kopier følgende kode ind i en editor.

class JavaException {
   public static void main(String args[]){
      int d = 0;
      int n = 20;
      int fraction = n/d;
     System.out.println("End Of Main");
   }
}

Trin 2) Gem filen og kompilér koden. Kør programmet ved hjælp af kommandoen java. JavaUndtagelse.

Trin 3) En aritmetisk undtagelse, divideret med nul, vises for linje 5, og linje 6 udføres aldrig.

Trin 4) Lad os nu undersøge, hvordan try and catch vil hjælpe os med at håndtere denne undtagelse. Vi vil indsætte den undtagelsesfremkaldende kodelinje i en prøv blok, efterfulgt af en fangst blok. Kopier følgende kode ind i editoren.

class JavaException {
 public static void main(String args[]) {
  int d = 0;
  int n = 20;
  try {
   int fraction = n / d;
   System.out.println("This line will not be Executed");
  } catch (ArithmeticException e) {
   System.out.println("In the catch Block due to Exception = " + e);
  }
  System.out.println("End Of Main");
 }
}

Trin 5) Gem, kompiler og kør koden. Du vil få følgende output.

Som du ser, håndteres undtagelsen, og den sidste kodelinje udføres også. Bemærk også, at linje 7 ikke vil blive udført, fordi så snart en undtagelse er hævet, springer kontrolstrømmen til fangblokken.

Bemærk: ArithmeticException-objektet "e" indeholder information om den opståede undtagelse, hvilket kan være nyttigt, når der udføres genoprettelseshandlinger.

Java Undtagelsesklassehierarki

Når én catch-sætning er udført, omgås de andre, og udførelsen fortsætter efter try and catch-blokken. Indlejrede catch-blokke skal følge undtagelseshierarkiet fra den mest specifikke underklasse til den mest generelle overordnede klasse.

• Alle undtagelsesklasser i Java udvider klassen Throwable. Throwable har to underklasser, Error og Exception.
• Error-klassen definerer de undtagelser eller problemer, der ikke forventes at opstå under normale omstændigheder i dit program, for eksempel hukommelsesfejl, hardwarefejl eller JVM-fejl.
• Exception-klassen repræsenterer de undtagelser, der kan håndteres af dit program, og dit program kan gendanne fra disse undtagelser ved hjælp af try-and-catch-blokke.
• En RuntimeException er en underklasse af Exception-klassen. Undtagelser af denne type repræsenterer ukontrollerede undtagelser, der opstår under kørsel og ikke kan detekteres under kompilering. Gode eksempler omfatter divider-med-nul-undtagelser og null-pointer-undtagelser.
• IOException genereres under input- og output-operationer.
• Afbrudt undtagelse i Java genereres under flertrådede operationer, når en tråd afbrydes.

Eksempel: Indlejring af try and catch-blokke

Trin 1) Kopier følgende kode ind i en editor.

class JavaException {
 public static void main(String args[]) {
  try {
   int d = 1;
   int n = 20;
   int fraction = n / d;
   int g[] = {
    1
   };
   g[20] = 100;
  }
  /*catch(Exception e){
  	System.out.println("In the catch block due to Exception = "+e);
  }*/
  catch (ArithmeticException e) {
   System.out.println("In the catch block due to Exception = " + e);
  } catch (ArrayIndexOutOfBoundsException e) {
   System.out.println("In the catch block due to Exception = " + e);
  }
  System.out.println("End Of Main");
 }
}

Trin 2) Gem filen og kompilér koden. Kør programmet ved hjælp af kommandoen, Java Javaundtagelse.

Trin 3) Der genereres en ArrayIndexOutOfBoundsException. Skift værdien af ​​int d til 0. Gem, kompiler og kør koden.

Trin 4) En ArithmeticException skal genereres.

Trin 5) Fjern kommentaren fra linje 10 til linje 12. Gem, kompiler og kør koden.

Trin 6) Kompileringsfejl? Dette skyldes, at Exception er basisklassen for ArithmeticException. Enhver undtagelse, der genereres af ArithmeticException, kan også håndteres af Exception-klassen. Så catch-blokken i ArithmeticException vil aldrig få en chance for at udføres, hvilket gør den redundant. Derfor kompileringsfejlen.

Java Bloker endelig

Den endelige blok er udføres, uanset om der er rejst en undtagelse i prøveblokken. det er valgfri at bruge med en try-blok. Finally-blokken er det rette sted at frigive ressourcer såsom databaseforbindelser, filer eller netværkssockets.

 try {
  statement(s)
 } catch (ExceptiontType name) {

  statement(s)

 } finally {

  statement(s)

 }

Hvis der opstår en undtagelse i try-blokken, udføres finally-blokken, efter at catch-blokken er fuldført.

Eksempel på endelig blokering

Trin 1) Kopier følgende kode ind i en editor.

class JavaException {
   public static void main(String args[]){
    try{
       int d = 0;
       int n =20;
       int fraction = n/d;
    }
  catch(ArithmeticException e){
    System.out.println("In the catch block due to Exception = "+e);
  }
  finally{
	System.out.println("Inside the finally block");
  }
}
}

Trin 2) Gem, kompiler og kør koden.

Trin 3) Forventet output: Finally-blokken udføres, selvom en undtagelse er oprettet.

Trin 4) Rediger værdien af ​​variablen d = 1. Gem, kompiler og kør koden, og observer outputtet.

Bedste praksis for Java undtagelse Håndtering

At følge et par velprøvede regler vil hjælpe dig med at holde din Java koderobust, læsbar og nem at debugge:

• Fang først den mest specifikke undtagelse, derefter de mere generelle, for at bevare integriteten af ​​undtagelseshierarkiet.
• Undgå tomme catch-blokke. Log som minimum undtagelsen, så den grundlæggende årsag aldrig går tabt.
• Brug finally-blokken, eller prøv med ressourcer at frigive filer, sockets og databaseforbindelser.
• Kast kun kontrollerede undtagelser, når kalderen med rimelighed kan gendanne fejl, og brug ukontrollerede undtagelser til programmeringsfejl.
• Pak lavniveau-undtagelser ind i en meningsfuld forretningsundtagelse for at holde API-konformiteten oppetracts rent.
• Sluk aldrig InterruptedException lydløst i multitrådet kode, gendan i stedet afbrydelsesflaget.

Ofte Stillede Spørgsmål