Tutoriel de gestion des exceptions Java

View more Tutorials:

1- Qu'est-ce qu'Exception ?

Tout d'abord, nous verrons 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: 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 de l'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.
 
Voir le flux du programme par les illustrations ci-dessous.
  • Le programme a exécuté tout à fait normal dans les étapes (1), (2) à (5)
  • Dans l'étape (6),le  problème se produit  lorsque divisé par 0.
  • Le programme a été à sauter hors de la fonction principale et la ligne de code septième (7) n'a pas été réalisée.
on va corriger le code de l'exemple ci-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 ce code suivant ne sera pas exécuté.
			System.out.println("Value =" + value);

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

			// les code dans catch  seront  exécutés.
			System.out.println("Ignore...");

		}

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

	}

}
Et les résultats de l'exécution d'exemple:
Nous allons expliquer dans l'illustration suivante du flux de programme.
  • Les étapes (1)-(5) tout à fait normal.
  • Les exceptions sont produites à l'étape (6), le problème divisé par 0.
  • Immédiatement il a sauté pour exécuter des commandes dans le bloc de capture, l'étape (7) est ignoré.
  • Les étapes (8), (9) sont exécutées.
  • L'étapes (10) est exécutée.

2- Hiérarchie des exceptions

C'est un diagramme de modèle de la hiérarchie d' 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 , est l'exception que Java ne sera pas vérifiée 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 Erreur ou Exception, ne pas écrire directement hérité de Throwable.

Error

Lorsque la défaillance de la liaison dynamique, ou dans une machine virtuelle se produit un grave problème, il renvoie  l'Erreur. Les programmes Java typiques ne doivent pas attraper l'erreur (Erreur). De plus, il est peu probable que les programmes Java typique ne seront jamais lancés Erreurs
Des 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. Le cas d' Exception indique un problème 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 différents types d'exceptions qui peuvent se produire. Par exemple,  NegativeArraySizeException est jetée lorsque vous essayez de créer un tableau (tableau) qui ont un certain nombre d'éléments négatifs.

La sous-classe Exception a une signification particulière dans la langue Java:  RuntimeException .

Runtime Exceptions

La classe  RuntimeException représente les exceptions qui se produisent en cours d'exécution du programme (pendant l'exécution). Un exemple d'une exception d'exécution est  NullPointerException , qui se produit lorsque vous accédez méthode ou champ d'un objet via une référence  null . A l'exception de ce type  généralement vérifier pour s'assurer que cette autre  null objet, plutôt que d'intercepter l'exception.
Parce que les exceptions Runtime sont très fréquents et essayer d'attraper ou spécifier chacun d'eux n'est pas efficace. Le compilateur Java ne vérifie pas ces exceptions  dans le processus de compilation du code.
Java définit certaines couches de classes  RuntimeException . Vous pouvez saisir ces exceptions tout comme d'autres exceptions. Les méthodes qu'elles peuvent jeter  RuntimeExceptions ne nécessitent pas de déclaration sur sa définition. De plus, vous pouvez créer vos propres sous-classes  RuntimeException .

3- Gérer l'exception avec try-catch

Nous écrivons une exception 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 les contrôles d'â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 poignées:
  1. Jeté à la bague extérieure
  2. Réaliser de rattraper et poigner 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érifiez l'âge.
		System.out.println("Check your Age");
		int age = 50;

		try {

			AgeUtils.checkAge(age);

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

		} catch (TooYoungException e) {

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

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

		}

	}
}
L'exemple ci-dessous, nous allons regrouper Intercepter les exceptions par exception au niveau supérieur. Au niveaux plus élevés, il attrapera des exceptions et tous les sous-classes 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 au même bloc pour gérer si elles ont des manières de manipulation similaires sur votre logique programme.
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 provoquer l'exception TooOldException 
			// ou TooYoungException
			AgeUtils.checkAge(age);

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

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

		}
	}

}

4-  try-catch-finally

Nous nous sommes habitués à attraper l'erreur à travers le bloc try-catch. La gestion des exceptions complet est le bloc try-catch-finally 
try {

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

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

   // Faites quelque chose ici .
} finally {

   // Le bloc finally 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 provoquer l'exception NumberFormatException.
			int value = Integer.parseInt(text);

			return value;

		} catch (NumberFormatException e) {

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

			// Lordque NumberFormatException se produit, renvoie 0.
			return 0;

		} finally {

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

		}
	}

}
Voici le flux schématique du programme. Enfin les blocs sont toujours exécutées.

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);
      }
}
Classe  ValidateException enroule un 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érifiez l'âge.
			// Valide si entre 18-40
			// Cette méthode peut jeter TooOldException,TooYoungException.
			AgeUtils.checkAge(person.getAge());

		} catch (Exception e) {

			// Sinon valide
			// Enveloppez cette exception par ValidationException et jetez (throw).
			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 {

			// L'exception peut se produire ici..
			ValidateUtils.checkPerson(person);

		} catch (ValidateException wrap) {

			// ​​​​​​​
			// Donnez la vraie cause.
			// Peut-êtreTooYoungException, 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 en temps de compilation. Dans certains cas, vous pouvez écrire vos propres exceptions héritées de cette branche. Il y a quelques exceptions dans cette branche sont disponibles en java, vous avez besoin de le regarder.

Voici quelques classes appartenant à branche  RuntimeException  (Bien sûr, ce n'est pas tout).
Nous avons essayé quelques exemples de la gestion de ces exceptions :

6.1- NullPointerException

C'est l'une des exceptions les plus courantes qui provoque généralement une erreur dans le programme. L'exception est rejetée lorsque vous appelez la méthode ou que vous accédez 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:
 
En réalité, comme pour gérer d'autres exceptions, vous pouvez utiliser des tentatives pour attraper et gérer cette exception. Cependant, c'est mécaniquement, normalement, nous devons vérifier que l'objet ne soit pas une valeur nulle avant de l'utiliser.

Vous pouvez corriger le code ci-dessus pour le rendre similaire à celui-ci à l'évidence de NullPointerException:
 
// Méthode getString() renvoie une valeur null.
// C'est une variable dont la référence est null.
String text2 = getString();

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

6.2- ArrayIndexOfBoundException

 Ceci est une exception, il est jeté lorsque vous essayez d'accéder à l'élément d'index dans le tableau est invalide. Un tel tableau a 10 éléments, vous accédez à nouveau l'élément d'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 produit 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");
}

View more Tutorials: