La gestion des exceptions en Java est l'un des mécanismes puissants pour gérer les erreurs d'exécution causées par les exceptions. La gestion des exceptions joue un rôle important dans le développement de logiciels. Cet article vous aide à comprendre l'exception Java, l'exception en Java, la gestion des exceptions Java, la hiérarchie des exceptions Java, les types d'exception en Java et bien d'autres.

Qu'est-ce que la gestion des exceptions en Java ?

La gestion des exceptions dans Java aide à minimiser les exceptions et aide à récupérer des exceptions. C'est l'un des mécanismes puissants pour gérer les exceptions d'exécution et le rend sans bogue. La gestion des exceptions aide à maintenir le déroulement du programme. Une gestion des exceptions est définie comme une condition anormale qui peut se produire lors de l'exécution et perturber le déroulement normal du programme.

Lisez aussi: Tutoriel Java pour débutants

Qu'est-ce qu'une exception ?

Une attente est un événement inattendu qui se produit lors de l'exécution du programme et qui perturbe le flux normal du code.

Gestion des exceptions en Java avec un exemple :

Disons,

statement
statement
statement
exception ………… an exception occurred, then JVM will handle it and will exit the prog.
statement
statement
statement

Pour gérer les exceptions, il existe 2 approches possibles

1.JVM

Si une exception n'est pas gérée explicitement, la JVM prend la responsabilité de gérer l'exception.

Une fois l'exception traitée, JVM arrêtera le programme et plus aucune exécution de code n'aura lieu

import java.util.*;

class Main {
    public static void main (String[] args) {
        System.out.println(5/0);
        System.out.println("End of program!");
	}
}

Erreur d'exécution:

 Exception dans le thread "main" java.lang.ArithmeticException : / par zéro à Main.main(File.java:5) 

2. Développeur

Les développeurs peuvent explicitement écrire l'implémentation pour gérer l'exception. Une fois qu'une exception est gérée, l'exécution normale du code se poursuit.

Préférable: gérez les exceptions pour vous assurer que votre code est exécuté normalement.

Hiérarchie des exceptions Java

Hiérarchie des exceptions – Voici la hiérarchie de gestion des exceptions dans Java.

• Jetable - 
  • C'est la classe racine de la hiérarchie des exceptions en Java. 
  • Il se trouve dans le package java.lang.
• Erreur - 
  • Sous-classe de Throwable.
  • Consiste en une condition anormale qui est hors de son contrôle et dépend de l'environnement
  • Ils ne peuvent pas être manipulés et entraîneront toujours l'arrêt du programme.
  • Par exemple : StackOverFlowError qui peut se produire en boucle infinie ou en récursivité
• Exception -
  • Sous-classe de Throwable.
  • Consiste en des conditions anormales qui peuvent être traitées explicitement.
  • Si l'on gère l'exception, notre code continuera à s'exécuter sans problème.

Types d'exception en Java

• Exceptions vérifiées
  • Les exceptions vérifiées au moment de la compilation comprennent les exceptions vérifiées.
  • Ce sont des classes enfants de Exception, à l'exception de RuntimeException.
  • Le programme ne compilera pas s'ils ne sont pas gérés.
  • Exemple : IOException, ClassNotFoundException, etc.
• Exceptions non cochées
  • Les exceptions vérifiées au moment de l'exécution comprennent les exceptions non vérifiées.
  • Ce sont des classes enfants de RuntimeException.
  • Ils génèrent des erreurs d'exécution s'ils ne sont pas gérés explicitement.
  • Exemple : ArithmeticException, NullPointerException, etc.

Différence entre les exceptions cochées et non cochées

Index des exceptions Java

Mots-clés d'exception Java

La gestion des exceptions en Java est gérée via cinq mots-clés : try, catch, throw, throws et enfin. Voici 5 mots-clés utilisés dans la gestion des exceptions en Java

Bloc Java Try-Catch

Syntaxe try-catch :

try{
}
catch(Exception e){
}

• Try-catch Exemple :

public class ExceptionDemo {
	public static void main (String[] args) {
		int a=10;
		for(int i=3;i>=0;i--)
		   try{
		     System.out.println(a/i);  
		   }catch(ArithmeticException e){
		       System.out.println(e);
		   }
	}
}

Sortie :

3 5 10 java.lang.ArithmeticException : / par zéro 

• Essai block contient le code susceptible de lever une exception. N'écrivez rien de plus dans try car les instructions après l'exception ne seront pas exécutées si l'exception s'est produite. Try doit être immédiatement suivi de catch ou de finally block.

public class ExceptionDemo {
	public static void main (String[] args) {
		int a=10;
		for(int i=3;i>=0;i--)
		   try{
		     System.out.println(a/i);  
		   }
	}
}

Erreur de compilation :

prog.java:5: erreur : 'try' sans 'catch', 'finally' ou déclarations de ressources try{ ^ 1 erreur 

• Le bloc catch est utilisé pour intercepter l'exception levée par les instructions dans le bloc try. Le catch doit suivre try sinon cela donnera une erreur de compilation.

public class ExceptionDemo {
	public static void main (String[] args) {
		int a=10;
		for(int i=3;i>=0;i--)
		   try{
		     System.out.println(a/i);  
		   }
		   System.out.println("between try and catch");
		   catch(ArithmeticException e){
		       System.out.println(e);
		   }
	}
}

Erreur de temps de compilation :

prog.java:5: erreur : 'try' sans 'catch', 'finally' ou déclarations de ressources try{ ^ prog.java:9: erreur : 'catch' sans 'try' catch(ArithmeticException e){ ^ 2 erreurs 

Choses dont il faut se rappeler:

Ne conservez aucun code après l'instruction qui est sujet à exception. Parce que si une exception se produisait, elle passerait immédiatement au catch ou au bloc finally, ignorant toutes les autres instructions du bloc try.

class Main {
	public static void main (String[] args) {
         try
       {
             System.out.println(4/0);
	 //will not get printed
             System.out.println("end of try!");
        }
catch(ArithmeticException e)
        {
            System.out.println("divide by 0");
        }
    }
}

Sortie :

diviser par 0

• Lors de la capture de l'exception dans le bloc catch, vous pouvez soit avoir directement la classe de l'exception, soit sa superclasse.

Exemple : Exception exacte

class Main {
	public static void main (String[] args) {
        try{
            System.out.println(4/0);
           }
      
        //ArithmeticException 
        catch(ArithmeticException e){
            System.out.println("divide by 0");
        }
    }
}

Sortie :

diviser par 0

Exemple : superclasse d'exception exacte

class Main {
	public static void main (String[] args) {
        try{
            System.out.println(4/0);
           }
      
        //superclass of ArithmeticException 
        catch(Exception e){
            System.out.println("divide by 0");
        }
     }
}

Sortie:

diviser par 0

Bloc de capture multiple Java

Si vous avez plusieurs captures, vous devez maintenir la hiérarchie de la sous-classe à la super-classe.

Incorrect:

class Main {
	public static void main (String[] args) {
        try{
            System.out.println(4/0);
        }catch(Exception e)
        {
            System.out.println("Exception : divide by 0");
        }catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException :divide by 0");
        }
	}
}

Erreur de compilation :

 prog.java:11 : erreur : l'exception ArithmeticException a déjà été détectée }catch(ArithmeticException e) ^ 1 erreur 

Correct:

class Main {
	public static void main (String[] args) {
        try{
            System.out.println(4/0);
        }catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException : divide by 0");
        }catch(Exception e)
        {
            System.out.println("Exception : divide by 0");
        }
   }
}

Sortie :

ArithmeticException : Diviser par 0

Essai imbriqué Java

Lorsqu'il y a un autre bloc try dans le bloc try :

class Main {
	public static void main (String[] args) {
        try{
                try{
                    int[] a={1,2,3};
                    System.out.println(a[3]);
                }
   catch(ArrayIndexOutOfBoundsException e)
                {
                    System.out.println("Out of bounds");
                }
              System.out.println(4/0);
        }
       catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException : divide by 0");
        }
	}
    }

Sortie :

Hors limites ArithmeticException : Diviser par 0 

Remarque - Si nous plaçons le code de l'essai externe avant l'essai interne, alors si une exception se produit, il ignorera l'intégralité de l'essai interne et passera directement à son bloc catch.

class Main {
	public static void main (String[] args) {
        try{
               System.out.println(4/0);
               try{
                    int[] a={1,2,3};
                    System.out.println(a[3]);
                }
   catch(ArrayIndexOutOfBoundsException e)
                {
                    System.out.println("Out of bounds");
                }
        }
       catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException : divide by 0");
        }
	}
    }

Sortie :

ArithmeticException : Diviser par 0

Java enfin bloquer

Contient du code qui doit être exécuté, qu'une exception soit levée ou non. Il contient le code de libération du fichier, la fermeture des connexions, etc.

• Flux de travail de finalement :

class Main {
	public static void main (String[] args) {
        try{
            System.out.println(4/0);
        }catch(Exception e)
        {
            System.out.println(e);       
        }
        finally
        {
            System.out.println("finally executed");
        }
        
       	        System.out.println("end");
	}
}

Sortie :

java.lang.ArithmeticException: / by zero finalement exécuté fin 

Enfin, s'exécutera même si nous ne gérons pas les exceptions. Avant d'arrêter le programme, la JVM vérifie s'il existe un bloc "finally".

class Main {
	public static void main (String[] args) {
        try{
            System.out.println(4/0);
            
        }finally
        {
            System.out.println("cleaning.......");
        }
	}
}

Erreur d'exécution:

 Exception dans le thread "main" java.lang.ArithmeticException : / par zéro à Main.main(File.java:4) 

Sortie :

nettoyage.......

Java Final vs Enfin vs Finaliser

Mot-clé Java Throw

Il s'agit d'un mot-clé utilisé pour lever explicitement une exception.

Nous pouvons utiliser throw où, selon notre logique, une exception devrait se produire.

Exemple:

public class ExceptionDemo {
	static void canVote(int age){
		if(age<18)
            try{
                throw new Exception();
            }catch(Exception e){
                System.out.println("you are not an adult!");
            }
		else
		   System.out.println("you can vote!");
	}
	public static void main (String[] args) {
		canVote(20);
		canVote(10);
	}
}

Sortie :

vous pouvez voter ! tu n'es pas majeur ! 

Java lance un mot-clé

• Le mot-clé throws est utilisé lorsque l'appelé ne veut pas gérer l'exception plutôt qu'il souhaite étendre cette responsabilité de gestion de l'exception à l'appelant de la fonction.
• Indique essentiellement quel type d'exception le code peut lancer et s'appuie sur l'appelant pour le gérer.
• Il est utilisé pour gérer les exceptions cochées car le compilateur n'autorisera pas la compilation du code tant qu'elles ne seront pas gérées.

Mise en situation :

public class ExceptionDemo {
	static void func(int a) throws Exception{
		   System.out.println(10/a);  
	}
	public static void main (String[] args) {
		try{
		    func(10);
		    func(0);
		}catch(Exception e){
		   System.out.println("can't divide by zero");
		}
	
	}
}

Sortie :

1 ne peut pas diviser par zéro 

Si l'appelé peut lever plusieurs exceptions, alors toutes seront levées simultanément.

import java.util.*;

public class ExceptionDemo {
	static void func(int a,int b) throws ArithmeticException, ArrayIndexOutOfBoundsException{
		   System.out.println(10/a); 
		   int[] arr={1,2,3};
		   System.out.println(arr[b]);
	}
	public static void main (String[] args) {
		Scanner in=new Scanner(System.in);
		for(int i=0;i<3;i++){
		try{
		    func(in.nextInt(),in.nextInt());
    		}catch(ArithmeticException e){
    		   System.out.println("can't divide by zero");
    		}catch(ArrayIndexOutOfBoundsException e){
    		   System.out.println("Out of bounds!");
    		}
		     }
		
	}
   }

Contribution:

2 1 0 1 2 3 

Sortie :

5 2 ne peut pas diviser par zéro 5 Hors limites ! 

Lancer Java vs lancers

Exception personnalisée Java

Vous pouvez créer votre propre exception et indiquer comment elle doit se comporter. Votre exception se comportera comme une classe enfant d'Exception.

Syntaxe:

 class YourException extends Exception{}

• Mise en situation :
  • disons que vous travaillez avec une compagnie aérienne 
  • Vous êtes dans le service d'enregistrement des bagages et conformément aux règles, vous pouvez prévoir 15 kg par client.
  • Alors maintenant, plus de 15 kg de poids est une condition anormale pour nous ou en d'autres termes, c'est une exception
  • Ceci est notre exception basée sur la logique, nous allons donc créer notre exception personnalisée WeightLimitExceeded 
  • Conformément à la syntaxe, il étendra Exception.
  • Nous définissons le constructeur qui sera invoqué dès qu'une exception sera levée
  • Nous devons lever explicitement l'exception et nous utiliserons donc le mot-clé throw pour cela.
  • L'utilisation du mot-clé throws correspond à nos besoins. Si nous gérons une exception là où elle est levée, nous pouvons éviter les lancers, sinon nous utiliserons les lancers et les gérerons dans l'appelant.

Mise en œuvre:

import java.util.*;

class WeightLimitExceeded extends Exception{
    WeightLimitExceeded(int x){
        System.out.print(Math.abs(15-x)+" kg : ");
    }
}


class Main {
    void validWeight(int weight) throws WeightLimitExceeded{
        if(weight>15)
            throw new WeightLimitExceeded(weight);
        else
            System.out.println("You are ready to fly!");
    }
    
      public static void main (String[] args) {
        Main ob=new Main();
        Scanner in=new Scanner(System.in);
        for(int i=0;i<2;i++){
            try{
                ob.validWeight(in.nextInt());
            }catch(WeightLimitExceeded e){
                System.out.println(e);
            }
        }
        
	}
}

Entrée:

20 7 

Sortie:

5 kg : WeightLimitExceeded Vous êtes prêt à voler ! 

Gestion des exceptions en Java avec remplacement de méthode

La gestion des exceptions en Java avec le remplacement de méthode est un méthode surchargée qui déclare lever une exception et déclarer qu'elle peut lever la même exception ou le même sous-type de cette exception.

Pour gérer l'exception en Java, vous devrez suivre trois règles importantes. Ils sont représentés dans la figure ci-dessous.

Avantages et inconvénients de la gestion des exceptions en Java

Avantages de l'exception de la gestion en Java 

• Séparer le code de gestion des erreurs du code "normal"
• Propagation des erreurs vers le haut de la pile d'appels
• Regroupement et différenciation des types d'erreur

Inconvénients de la gestion des exceptions en Java 

• Subir des frais généraux inutiles
• Ne pas comprendre le fonctionnement réel de l'application
• Remplir vos journaux d'événements bruyants
• Incapacité à se concentrer sur ce qui compte vraiment

Cela nous amène à la fin de cet article sur la gestion des exceptions en Java. Nous espérons que vous avez maintenant compris le concept de gestion des exceptions en Java. Si vous souhaitez en savoir plus sur le langage de programmation java, connectez-vous à notre cours de programmation java et avancez dans votre carrière.

Regardez aussi: