Tutoriel de gestion des exceptions Java

Qu'est-ce qu'Exception ?
Hiérarchie des exceptions
Gestion de l'exception avec try-catch
Le bloc try-catch-finally
Emballer une Exception dans une autre Exception
RuntimeException et les sous-classe

1. Qu'est-ce qu'Exception ?

Tout d'abord, nous observerons un exemple dans l'illustration suivante :

Dans cet exemple, il y a un code d'erreur qui résulte de la division par 0. La division par 0 provoque l'exception: ArithmeticException

HelloException.java

package org.o7planning.tutorial.exception;

public class HelloException {

	public static void main(String[] args) {

		System.out.println("Three");

		// Cette division n'a aucun problème.
		int value = 10 / 2;

		System.out.println("Two");

		// Cette division n'a aucun problème.
		value = 10 / 1;

		System.out.println("One");

		// Cette division a un problème, divisé par 0.
		// Une erreur s'est produite ici.
		value = 10 / 0;

		// Et le code suivant ne sera pas exécuté.
		System.out.println("Let's go!");

	}

}

Les résultats d'exécution de l'exemple :
Vous pouvez voir la notification sur l'écran de Console. La notification d'erreur est très claire, y compris l'information de la ligne de code.

Three
Two
One
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at org.o7planning.tutorial.exception.HelloException.main(HelloException.java:31)

Observez le flux du programme par les illustrations ci-dessous :

Le programme exécute tout à fait normal dans les étapes (1), (2) à (5)
Dans l'étape (6),le problème se produit lorsque le programme est divisé par 0.
Le programme saute hors de la fonction principale et la ligne de code (7) n'a pas été réalisée.

On va modifier le code de l'exemple au-dessus.

HelloCatchException.java

package org.o7planning.tutorial.exception;

public class HelloCatchException {

	public static void main(String[] args) {

		System.out.println("Three");

		// Cette division est absolument aucun problème.
		int value = 10 / 2;

		System.out.println("Two");

		// Cette division n'a pas de problème.
		value = 10 / 1;

		System.out.println("One");

		try {
			// Cette division a un problème, divisé par 0.
			// Une erreur s'est produite ici.
			value = 10 / 0;

			// Et le code suivant ne sera pas exécuté.
			System.out.println("Value =" + value);

		} catch (ArithmeticException e) {
			// Et le code dans le bloc catch  sera  exécuté.
			System.out.println("Error: " + e.getMessage());

			// Le code dans le bloc catch sera  exécuté.
			System.out.println("Ignore...");

		}

		// Ce code sera exécuté.
		System.out.println("Let's go!");

	}

}

Et les résultats d'exécution de l'exemple :

Three
Two
One
Error: / by zero
Ignore...
Let's go!

Nous allons expliquer le flux du programme par l'illustration suivante :

Des étapes (1)-(5) tout à fait normal.
Les exceptions se produisent dans l'étape (6), le problème est divisé par 0.
Immédiatement il saute pour exécuter des commandes dans le bloc de capture, l'étape (7) est ignorée.
Des étapes (8), (9) sont exécutées.
L'étapes (10) est exécutée.

2. Hiérarchie des exceptions

C'est le modèle de diagramme hiérarchique de Exception en Java.

La classe au plus haut niveau est Throwable
Deux sous-classes directes sont Erreur et Exception.

Dans la branche Exception, il existe une sous-classe RuntimeException, qui sont des exceptions que Java ne sera pas vérifiées dans le temps de compilation. La signification de vérifier et de décocher au moment de la compilation sera illustrée dans les exemples de la partie suivante.

Remarque : Votre classe personnalisée devrait écrire héritée de deux branches Error ou Exception, n'est pas directement hérité de Throwable.

Error

Lorsque la défaillance de la liaison dynamique, ou autre défaillance importante dans une machine virtuelle se produit un grave problème, il renvoie un Error. Les programmes Java typiques ne doivent pas attraper l'erreur (Error). De plus, il est peu probable que les programmes Java typique ne seront jamais lancés des Erreurs

L'exemples de liens dynamiques: Par exemple, lorsque vous appelez à la bibliothèque qui manque de classes, ou de méthode, ... dans ce cas Erreur sera jeté.

Exceptions

La plupart des programmes lancent et rattrappent des objets issus de la classe Exception. Dans le cas où Exception indique un problème qui s'est produit mais que le problème n'est pas un grave problème systémique. La plupart des programmes que vous écrivez lanceront et attraperont des Exception.

La classe Exception a beaucoup de descendants définis dans les paquets Java. Ces descendants indiquent de différents types d'Exception qui peuvent se produire. Par exemple, NegativeArraySizeException est jetée lorsque vous essayez de créer un tableau qui contient des éléments négatifs.

Une sous-classe Exception a une signification particulière dans le langage Java, c'est RuntimeException.

Runtime Exceptions

La classe RuntimeException représente des exceptions qui se produisent lors de l'exécution du programme. Un exemple d'exécution d'une exception est NullPointerException, qui se produit lorsque vous accédez à une méthode ou au champ d'un objet via une référence null. Une NullPointerException peut se produire lorsq'un programme essaie de faire la référence à un objet. Le coût de la vérification de l'exception dépasse souvent l'avantage de la détecter.

Comme des exceptions Runtime sont très omniprésentes donc lorsque vous essayez de les attraper ou les spécifiez, ce sera un exercice infructueux. Le compilateur Java ne vérifie pas ces exceptions dans le processus de compilation du code.

Les paquets Java définissent quelques classes RuntimeException. Vous pouvez attraper (Catch) ces exceptions tout comme d'autres exceptions. Cependant, il n'est pas nécessaire qu'une méthode spécifie qu'elle génère des RuntimeExceptions. En plus, vous pouvez créer vos propres sous-classes RuntimeException.

3. Gestion de l'exception avec try-catch

Nous écrivons une classe qui hérite de la classe Exception.

AgeException.java

package org.o7planning.tutorial.exception.basic;

public class AgeException extends Exception {

  public AgeException(String message) {
      super(message);
  }

}

TooYoungException.java

package org.o7planning.tutorial.exception.basic;

public class TooYoungException extends AgeException {

 public TooYoungException(String message) {
     super(message);
 }

}

TooOldException.java

package org.o7planning.tutorial.exception.basic;

public class TooOldException extends AgeException {

 public TooOldException(String message) {
     super(message);
 }

}

Et la classe AgeUtils a des méthodes statiques utilisées pour examiner l'âge.

AgeUtils.java

package org.o7planning.tutorial.exception.basic;

public class AgeUtils {

	// Cette méthode vérifie l'âge.
	// Si l'âge est inférieur à 18 ans, il jettera TooYoungException
	// Si l'âge est supérieur à 40, il jettera TooOldException
	public static void checkAge(int age) throws TooYoungException, TooOldException {
		if (age < 18) {
			// Si l'âge est inférieur à 18 ans, une exception sera jetée TooYoungException
			// Cette méthode se termine ici.
			throw new TooYoungException("Age " + age + " too young");
		} else if (age > 40) {
			// Si l'âge est supérieur à 40, une exception sera jetée TooOldExcept
			// Cette méthode se termine ici.
			throw new TooOldException("Age " + age + " too old");
		}
		// Si l'âge est entre 18-40.
		// Ce code sera exécuté.
		System.out.println("Age " + age + " OK!");
	}
}

Checked Exception & Unchecked Exception:

AgeException est des sous-classes de Exception, TooOldException et TooYoungException sont deux sous-classes directes de AgeException, donc elles sont "Checked Exception"
Dans la méthode AgeUtils.checkAge (int) a jeté ces exceptions donc sur la déclaration de la méthode dont vous avez besoin de les lister via des mots clés « jette ». Ou vous pouvez déclarer jeté à un plus grand
- Jette des Exceptions (throws Exception).
Au lieu d'utilisation AgeUtils.checkAge (int) doit également être traité pour rattraper les exceptions, ou de continuer à jeter la bague extérieure.

Checked exception" sera vérifié par "Java Compiler".

Vous avez deux choix :

Jeter à la bague extérieure
Réaliser de rattraper et résoudre les exceptions via try-catch

TryCatchDemo1.java

package org.o7planning.tutorial.exception.basic;

public class TryCatchDemo1 {

	public static void main(String[] args) {

		// Commencer à recruter ...
		System.out.println("Start Recruiting ...");
		// Vérifier l'âge.
		System.out.println("Check your Age");
		int age = 50;

		try {

			AgeUtils.checkAge(age);

			System.out.println("You pass!");

		} catch (TooYoungException e) {

			// Faire quelque chose ici ...
			System.out.println("You are too young, not pass!");
			System.out.println(e.getMessage());

		} catch (TooOldException e) {
			// Faire quelque chose ici ...
			System.out.println("You are too old, not pass!");
			System.out.println(e.getMessage());

		}

	}
}

Dans l'exemple suivant, nous allons attraper les exceptions par le biais des exceptions parent (classe super exception).

TryCatchDemo2.java

package org.o7planning.tutorial.exception.basic;

public class TryCatchDemo2 {

	public static void main(String[] args) {

		// Commencer à recruter
		System.out.println("Start Recruiting ...");
		// Vérifiez votre âge.
		System.out.println("Check your Age");
		int age = 15;

		try {
			// Cela peut développer l'exception TooOldException
			// ou TooYoungException
			AgeUtils.checkAge(age);

			System.out.println("You pass!");

		} catch (AgeException e) {
			// Si une exception se produit, type AgeException.
			// Ce bloc catch sera exécuté.
			System.out.println("Your age invalid, you not pass");
			System.out.println(e.getMessage());

		}
	}
}

Vous pouvez également regrouper différentes exceptions dans le même bloc pour les gérer si elles ont des manières de traitement similaires sur votre programme logique.

TryCatchDemo3.java

package org.o7planning.tutorial.exception.basic;

public class TryCatchDemo3 {

	public static void main(String[] args) {

		System.out.println("Start Recruiting ...");

		System.out.println("Check your Age");
		int age = 15;

		try {
			// Cela peut soulever une exception TooOldException ou TooYoungException.
			AgeUtils.checkAge(age);

			System.out.println("You pass!");

		} catch (TooYoungException | TooOldException e) {
			// Attraper plusieurs exceptions dans un seul bloc.
			System.out.println("Your age invalid, you not pass");
			System.out.println(e.getMessage());

		}
	}

}

4. Le bloc try-catch-finally

Nous nous sommes habitués à l'erreur de capture à travers le bloc try-catch. Try-catch-finally est utilisé pour gérer entièrement les exceptions.

try {

   // Faites quelque chose ici.
} catch (Exception1 e) {

   // Faites quelque chose ici.
} catch (Exception2 e) {

   // Faites quelque chose ici.
} finally {

   // Le bloc final est toujours exécuté.
   // Faites quelque chose ici.
}

TryCatchFinallyDemo.java

package org.o7planning.tutorial.exception.basic;

public class TryCatchFinallyDemo {

	public static void main(String[] args) {

		String text = "001234A2";

		int value = toInteger(text);

		System.out.println("Value= " + value);

	}

	public static int toInteger(String text) {
		try {

			System.out.println("Begin parse text: " + text);

			// Cela peut augmenter l'exception NumberFormatException.
			int value = Integer.parseInt(text);

			return value;

		} catch (NumberFormatException e) {

			// Dans le cas de "texte" n'est pas un nombre.
			// Ce bloc catch sera exécuté.
			System.out.println("Number format exception " + e.getMessage());

			// Renvoie 0 si NumberFormatException se produit
			return 0;

		} finally {

			System.out.println("End parse text: " + text);

		}
	}

}

C'est le déroulement du programme. Finally, le bloc est toujours exécuté.

5. Emballer une Exception dans une autre Exception

Nous avons besoin des certaines classes ont participé à cet exemple:

Personne: Simuler un recrutement de participants dans l'entreprise avec les informations
- Nom, âge, sexe.
GenderException: Exception genre.
ValidateException: Exception évaluer les candidats.
ValidateUtils : Classe a une méthode statique évalue le candidat
- les standards sont les gens entre 18 à 40 ans
- Et les hommes

Person.java

package org.o7planning.tutorial.exception.wrap;

public class Person {

  public static final String MALE = "male";
  public static final String FEMALE = "female";

  private String name;
  private String gender;
  private int age;

  public Person(String name, String gender, int age) {
      this.name = name;
      this.gender = gender;
      this.age = age;
  }

  public String getName() {
      return name;
  }

  public void setName(String name) {
      this.name = name;
  }

  public String getGender() {
      return gender;
  }

  public void setGender(String gender) {
      this.gender = gender;
  }

  public int getAge() {
      return age;
  }

  public void setAge(int age) {
      this.age = age;
  }
}

GenderException.java

package org.o7planning.tutorial.exception.wrap;

// Exception de genre.
public class GenderException extends Exception {
 
      public GenderException(String message)  {
    	  super(message);
      }
}

La classe ValidateException emballe une autre Exception

ValidateException.java

package org.o7planning.tutorial.exception.wrap;

public class ValidateException extends Exception {
	
	// Emballer (wrap) Exception dans une autre Exception
	public ValidateException(Exception e)  {
		super(e);
	}

}

ValidateUtils.java

package org.o7planning.tutorial.exception.wrap;

import org.o7planning.tutorial.exception.basic.AgeUtils;

public class ValidateUtils {

	// Méthode pour vérifier une personne, 
	public static void checkPerson(Person person) throws ValidateException {
		try {

			// Vérifier l'âge.
			// Valable si entre 18 et 40 ans
			// Cette méthode peut lancer TooOldException, TooYoungException.      
			AgeUtils.checkAge(person.getAge());

		} catch (Exception e) {

			// Si non valide
			// Enveloppez cette exception par ValidateException, et lancez
			throw new ValidateException(e);

		}

		// Si cette personne est une femme, ==> invalide.
		if (person.getGender().equals(Person.FEMALE)) {

			GenderException e = new GenderException("Do not accept women");
			throw new ValidateException(e);

		}
	}

}

WrapperExceptionDemo.java

package org.o7planning.tutorial.exception.wrap;

public class WrapperExceptionDemo {

	public static void main(String[] args) {

		// Un candidat.
		Person person = new Person("Marry", Person.FEMALE, 20);

		try {

			// Des exceptions peuvent se produire ici.
			ValidateUtils.checkPerson(person);

		} catch (ValidateException wrap) {

			// Trouvez la vraie cause.
			// Peut être TooYoungException, TooOldException, TooOldException, GenderException.
			Exception cause = (Exception) wrap.getCause();

			if (cause != null) {
				System.out.println("Not pass, cause: " + cause.getMessage());
			} else {
				System.out.println(wrap.getMessage());
			}

		}
	}

}

6. RuntimeException et les sous-classe

La classe RuntimeException et ses sous-classes sont toutes "exceptions non vérifiées"("Unchecked exception"). Il n'est pas vérifié par le compilateur Java lors de la compilation. Dans certains cas, vous pouvez écrire vos propres exceptions héritées de cette branche.

Ci-dessous se trouvent quelques classes appartenant à la branche RuntimeException (Bien sûr, ce n'est pas tout).

Quelques exemples de gestion de ce type d'exceptions :

NullPointerException

C'est l'une des exceptions les plus courantes qui cause habituellement des erreurs au programme. L'exception est supprimée lorsque vous appelez la méthode ou l'accès aux champs d'un objet nul.

NullPointerExceptionDemo.java

package org.o7planning.tutorial.exception.runtime;

public class NullPointerExceptionDemo {

	// Example, here is a method that can return null string.
	public static String getString() {
		if (1 == 2) {
			return "1==2 !!";
		}
		return null;
	}

	public static void main(String[] args) {

		// This is a variable that references is not null.
		String text1 = "Hello exception";

		// Call the method to get the string length.
		int length = text1.length();

		System.out.println("Length text1 = " + length);

		// This is a variable that references is null.
		String text2 = getString();

		// Call the method to get length of string.
		// NullPointerException will occur here.
		// It is an exception occurs at runtime (type of RuntimeException).
		// Java compiler does not force you to catch it at compile-time.
		length = text2.length(); // ==> exception!

		System.out.println("Finish!");
	}

}

Les résultats de l'exécution de l'exemple :

Length text1 = 15
Exception in thread "main" java.lang.NullPointerException
    at org.o7planning.tutorial.exception.runtime.NullPointerExceptionDemo.main(NullPointerExceptionDemo.java:51)

En réalité, comme pour la gestion d'autres exceptions, vous pouvez utiliser try-catch pour capturer et gérer cette exception. Cependant, c'est mécanique, normalement, nous devrions vérifier que l'objet n'a pas une valeur nulle avant de l'utiliser.

Vous pouvez corriger le code ci-dessus pour le rendre similaire au suivant en évitant NullPointerException :

// getString() retourne une valeur nulle.
// C'est une variable dont la référence est nulle.
String text2 = getString();

// Vérifiez que'text2' n'est pas nul.
// Au lieu d'utiliser try-catch.
if (text2 != null) {
  length = text2.length();
}

ArrayIndexOfBoundException

Cette exception se produit lorsque vous essayez d'accéder à l'élément dont l'index est invalide dans le tableau. Par exemple, un tableau a 10 éléments, mais vous accédez à l'élément avec l'index 20.

ArrayIndexOfBoundsExceptionDemo.java

package org.o7planning.tutorial.exception.runtime;

public class ArrayIndexOfBoundsExceptionDemo {

	public static void main(String[] args) {

		String[] strs = new String[] { "One", "Two", "Three" };
		// Accès à l'élément à l'index 0.
		String str1 = strs[0];

		System.out.println("String at 0 = " + str1);

		// Accès à l'élément à l'index 5.
		// ArrayIndexOfBoundsException se produisent ici.
		String str2 = strs[5];

		System.out.println("String at 5 = " + str2);

	}

}

Pour éviter ArrayIndexOfBoundsException vous vérifiez le tableau au lieu d'utiliser try-catch.

if (strs.length > 5) {
   String str2 = strs[5];
   System.out.println("String at 5 = " + str2);
} else {
   System.out.println("No elements with index 5");
}