Java >> Tutoriel Java >  >> Java

Gestion des exceptions avec exemple en Java

Java

Dans l'article précédent (Les bases de la gestion des exceptions en Java), nous avons expliqué que nous pouvions implémenter la gestion des exceptions dans votre programme en utilisant les cinq mots clés suivants :

1) essayez

Le bloc essai contient une série d'instructions de programme dans lesquelles une exception peut se produire. Un bloc try est toujours suivi d'un bloc catch, qui capture l'exception survenue au niveau du bloc try.

Syntaxe : 

try{
    // block of code to monitor for errors
}

2) attraper()

Un bloc catch est toujours associé à un bloc try . Il intercepte l'erreur renvoyée par le bloc try lors de l'exécution du programme. Il contient l'objet de type de classe Exception. Les erreurs qui se produisent lors de l'exécution du programme génèrent un objet spécifique contenant les informations sur les erreurs survenues dans le programme.

Syntaxe : 

try {
	// block of code to monitor for errors
}
catch (ExceptionType1exOb) {
	// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb) {
	// exception handler for ExceptionType2
}

Dans l'exemple de code suivant, vous verrez comment la gestion des exceptions peut être fait dans le programme java.

Cet exemple lit deux nombres entiers pour les variables a et b. Si vous entrez un autre caractère à l'exception du nombre (0 - 9), l'erreur est interceptée par l'objet NumberFormatException. Après cela, ex.getMessage() imprime les informations sur les causes de l'erreur.

Considérez le programme : 

import java.io.*;

public class ExceptionHandle
{
	public static void main(String[] args) throws Exception
	{
		try{
			int a,b;
			DataInputStream in = new DataInputStream(System.in);
			a = Integer.parseInt(in.readLine());
			b = Integer.parseInt(in.readLine());
		}
		catch(NumberFormatException ex){
			System.out.println(ex.getMessage()
			+ " is not a numeric value.");
		}
		catch(IOException e){
			System.out.println(e.getMessage());
		}
	}
}

3) jeter un mot-clé

L'instruction throw provoque la fin du flux normal de contrôle du code Java et arrête l'exécution des instructions suivantes après l'instruction throw.

Auparavant, vous n'interceptiez que les exceptions levées par le système JRE. Cependant, il est possible que votre programme lève une exception explicitement, en utilisant le throw déclaration. La forme générale de lancer est affiché ici :

lancer ThrowableInstance ;

Nous utilisons simplement le mot clé throw avec une référence d'objet pour lever une exception. Un seul argument est requis par l'instruction throw, c'est-à-dire un objet jetable .

Considérez le programme : 

import java.util.*;

class ExceptionThrow
{ 
	public static void main(String arg[])
	{ 
		try{
			Scanner KB=new Scanner(System.in);
			System.out.print("Enter Percentage:");
			int per=KB.nextInt();
			if(!(per>=0 && per<=100))
			{ 
				throw(new Exception("Invalid Percentage...."+per));
			}
			else
			{
				System.out.println("Valid Percentage...");
			}
		}catch(Exception e){
			System.out.println(e);
		} 
	}
}
Publicité

4) lance un mot-clé

La clause throws est utilisée par une méthode pour spécifier les types d'exceptions que la méthode lève. Le mot-clé throw indique ce qui suit :

  • Le mot clé throws dans le langage de programmation Java s'applique à une méthode pour indiquer que la méthode déclenche un type particulier d'exception lors de son traitement.
  • Le mot-clé throws du langage de programmation Java prend en argument une liste d'objets de type classe java.lang.Throwables.

La forme générale des lancers est donnée ci-dessous : 

type method-name(parameter-list) throws exception-list
{
    // body of method
}

Ici, exception-listest séparé par des virgules (liste des exceptions qu'une méthode peut lancer).

import java.io.*;

class ThrowsKeyword
{ 
	static int division(int x) throws ArithmeticException,NumberFormatException,IOException{ 
		DataInputStream KB=new DataInputStream(System.in);
		System.out.print("Enter Value..");
		int y=Integer.parseInt(KB.readLine());
		int d=x/y;
		return(d);
	}
	public static void main(String arg[])
	{ 
		try{
			int j=division(300);
			System.out.println(j);
		}
		catch(ArithmeticException e){
			System.out.println("Error:"+e.getMessage());
		}
		catch(NumberFormatException e){
			System.out.println("Invalid Input:"+e.getMessage());
		}
		catch(IOException e){
			System.out.println(e.getMessage());
		}
	}
}

5) Bloquer enfin

La clause finally est utilisée pour exécuter les instructions qui doivent être exécutées, qu'une exception ait été levée ou non .

Utiliser enfin clause après le try et attraper bloc pour gérer une exception inattendue survenue dans le bloc try .

Le bloc finally est exécuté de manière sûre, que l'exception soit générée ou non. Enfin, le bloc est exécuté une fois que l'exécution a quitté le bloc try et toutes les clauses catch associées, qu'une exception ait été levée ou interceptée.

La syntaxe de déclaration d'une variable de type final est : 

try {
	// Normal execution path
}
catch (ExampleExceptionee) {
	// deal with the ExampleException
}
finally {
	// This optional section is executed upon termination 
	//of any of the try or catch blocks above
}

Balise Java