Coursjava Lecon7 2022MY

Programmation OO en Java
Chapitre VII. Gestion des exceptions
Dr. Hassen Lazrag

Exception, Qu'est-ce que c'est?
Cours Java 2022 Hassen Lazrag

Exemple

Exemple d’introduction
package tn.iteam.exceptions;
public class ExceptionDemo {

public static void show(){
sayHello(null);
}
public static void sayHello(String name){

System.out.println(name.toLowerCase());
}
package tn.iteam;
import tn.iteam.exceptions.ExceptionDemo;
public class Main {
public static void main(String[] args) {

ExceptionDemo.show();
}
}

Execution

Exception, Qu'est-ce que c'est?

Que ce que une exception en java?
 Souvent, un programme doit traiter des situations exceptionnelles qui n'ont

pas un rapport direct avec sa tâche principale.
 Ceci oblige le programmeur à réaliser de nombreux tests avant d'écrire les
instructions utiles du programme. Cette situation a deux inconvénients
majeurs :
 Le programmeur peut omettre de tester une condition ;
 Le code devient vite illisible car la partie utile est masquée par les tests.
 Java remédie à cela en introduisant un Mécanisme de gestion des
exceptions .
 Grâce à ce mécanisme, on peut améliorer grandement la lisibilité du code
 En séparant
 le code utile (Code métier)
 de celui qui traite des situations exceptionnelles,

Type d’Exceptions

Type d’exceptions
Checked Unchecked Error

Types d’exceptions
 En Java, on peut classer les exceptions en deux catégories :

 Les exceptions surveillées,
 Les exceptions non surveillées.
 Java oblige le programmeur à traiter les erreurs surveillées.

Elles sont signalées par le compilateur
 Les erreurs non surveillées peuvent être traitées ou non. Et ne

sont pas signalées par le compilateur

Hiérarchies des Exceptions

Hiérarchie des exceptions
Throwable
Exception Error
RuntimeException

Hiérarchie des exceptions
On ne peut pas traiter les « Error »

Throwable
Exception Error
RunTime Exception IOException AWTError VirtualMachineError
NullPointerException FileNotFoundException OutOfMemoryError
ArithmeticException EOFException
AutresExceptionNonSurveillees AutresExceptionSurveillees
On doit traiter ces exceptions-ci
On n’est pas obligé de traiter ces exceptions-ci

Hiérarchie des exceptions :RuntimeException
 NullPointerException
 ArithmeticException
 IllegalArgumentException
 IndexOutOfBoudsException
 IllegalStateException

Runtime Exception: NullPointerException

Traitement des Exceptions

Principes

try-catch

Interception par bloc try – catch – finally
try
{
// quelques actions potentiellement risquées
}
catch(SomeException se)
{
// que faire si une exception de ce type survient
}
catch(Exception e)
{
// que faire si une exception d’un autre type survient
}
finally
{
// toujours faire ceci, quelle que soit l’exception
}

Schéma de fonctionnement de try – catch
 Dès qu'une exception est levée (instanciée),la

Java machine
 stoppe immédiatement l'exécution
normale du programme
 recherche un gestionnaire d'exception
susceptible d'intercepter (saisir)

 traiter cette exception.
 Cette recherche s'effectue à partir du bloc

englobant et se poursuit sur les blocs plus
englobants

Exemple 1:

try {
FileReader reader = new FileReader("file.txt");
System.out.println("File Opened");
} catch (FileNotFoundException e) {
System.out.println("File Not Exist.");
System.out.println(e.getMessage());
}
}


try-catch-finally

Exemple 3:

FileReader reader = null;
try {
reader = new FileReader("file.txt");
//System.out.println("File Not Exist.");
}
finally {
reader.close();
}
}


Interception de plusieurs bloc catch
Syntaxe
try{
 Où TypeException1, TypeException2, ... ,
<blocs de code à protéger>
} TypeExceptionk sont des classes
catch(TypeException1 se)
d'exceptions obligatoirement toutes
{
// Traitement Exception 1 distinctes.
}
catch(TypeException2 e)  Une seule clause catch (TypeException e )
{ {...} est exécutée  celle qui correspond au
// Traitement Exception 2
bon type de l'objet d'exception instancié.
}
……………
catch(TypeExceptionk e)
{
// Traitement exception k
}

Exemple 2:

try {
FileReader reader = new FileReader("file.txt");
int read = reader.read();
//System.out.println("File Not Exist.");
} catch (IOException e) {
System.out.println("Could not read data.");
}
}


Ordre d’interception d’exceptions hiérarchisées
Exemple

Lancement avec
throws & throw

Lancement avec les mots-clés throws et throw
 Une méthode dans laquelle est levée une ou plusieurs exceptions supervisées doit
obligatoirement signaler au compilateur quelles sont les classes d'exceptions
qu'elle laisse se propager.
 Java dispose d'un spécificateur pour ce signalement : le mot clef throws suivi de la
liste des noms des classes d'exceptions qui sont propagées
 Signature générale d'une méthode propageant des exceptions vérifiées
(surveillées)
<modificateurs> <type> < identificateur>( <liste param formels> )

throws < liste d'exceptions> {
.....
}
Exemple :
protected static void meth ( int x, char c )
throws IOException, ArithmeticException {
.....
}

Lancement avec les mots-clés throws et throw
 Si une exception peut survenir, mais que la méthode n’est pas censée la
traiter elle-même, il faut en « lancer » une instance
 Il faut préciser que la méthode peut lancer ces exceptions
 ajouter une clause throws à la signature de la méthode
public void writeList() {
PrintWriter out = new PrintWriter(new FileWriter("OutFile.txt"));
for (int i = 0; i < vector.size(); i++)
out.println("Valeur = " + vector.elementAt(i));
}
 Peut lancer une IOException  doit être attrapée

 Peut lancer une ArrayIndexOutOfBoundsException
public void writeList()throws IOException,

ArrayIndexOutOfBoundsException {

Un Premier Exemple

Un premier exemple
 Considérons une application qui permet de :

 Saisir au clavier deux entiers a et b
 Faire appel à une fonction qui permet de calculer et de retourner a

divisé par b.
 Affiche le résultat

Un premier exemple
import java.util.Scanner;
public class App1 {

public static int calcul(int a,int b){
int c=a/b;
return c;
}
Scanner clavier=new Scanner(System.in);
System.out.print("Donner a:");
int a=clavier.nextInt();
System.out.print("Donner b:");
int b=clavier.nextInt();
int resultat=calcul(a,b);
System.out.println("Resultat="+resultat);}

Exécution
 Nous constatons que le compilateur ne signale pas le cas ou b est égal à

zéro.
 Ce qui constitue un cas fatal pour l’application.
 Voyons ce qui se passe au moment de l’exécution
Scénario 1 : Le cas normal
Donner a:12
Donner b: 6
Resultat =2
Scénario 2 : cas où b=0
Donner a=12.
Donner b=0.
Exception in thread "main" java.lang.ArithmeticException: / by zero
at App1.calcul(App1.java:4)
at App1.main(App1.java:11)

Un bug dans l’application
 Le cas du scénario 2 indique qu’une erreur fatale s’est
produite dans l’application au moment de l’exécution.
 Cette exception est de type ArithmeticException. Elle
concerne une division par zéro
JVM
JVM
 L’origine de cette exception étant la méthode calcul
dans la ligne numéro 4. Exception
 Cette exception n’a pas été traité dans calcul. main

main
 Elle remonte ensuite vers main à la ligne numéro 11 Exception

dont elle n’a pas été traitée. calcul
Calcul
 Après l’exception est signalée à la JVM.
 Quand une exception arrive à la JVM, cette dernière
arrête l’exécution de l’application, ce qui constitue un
bug fatale.
 Le fait que le message « Resultat = » n’a pas été
affiché, montre que l’application ne continue pas son
exécution normal après la division par zéro.

Traiter l’exception
 Dans java, pour traiter les exceptions, on doit utiliser le bloc try catch
de la manière suivante:
import java.util.Scanner; Scénario 1
public class App1 {
public static int calcul(int a,int b){ Donner a:12
int c=a/b; Donner b:6
return c; Resultat=2
}
Scanner clavier=new Scanner(System.in); Scénario 2
System.out.print("Donner a:");int a=clavier.nextInt();
Donner a:12
System.out.print("Donner b:");int b=clavier.nextInt();
int resultat=0;
Donner b:0
try{ Divisio par zero
resultat=calcul(a, b); Resultat=0
}catch (ArithmeticException e){
System.out.println("Division par zero");
}
System.out.println("Resultat="+resultat);
}
}

Principale méthodes d’une Exception
 Tous les types d’exceptions possèdent les méthodes suivantes :

 getMessage() : retourne le message de l’exception
 System.out.println(e.getMessage());
 Résultat affiché : / by zero
 toString() : retourne une chaine qui contient le type de l’exception et le
message de l’exception.
 System.out.println(e.toString());
 Résultat affiché : java.lang.ArithmeticException:/ by zero
 printStackTrace: affiche la trace de l’exception
 e.printStackTrace();
 Résulat affiché
java.lang.ArithmeticException: / by zero
at App1.calcul(App1.java:4)
at App1.main(App1.java:13)

Redéfinition d’une méthode
propageant des Exceptions

Redéfinition d’une méthode propageant des Exceptions
 Si la méthode à redéfinir lance une exception supervisée
Exception Action1
meth() throws IOException,

NoSuchFieldField
NoSuchFieldExceptin IOException
Action2
CharConvertionException meth() throws CharConvertionException, IOException,

NoSuchFieldField

Redéfinition d’une méthode propageant des Exceptions

Exemple 2 :
Projet Compte

Générer, Relancer une exception surveillée de type Exception
 Considérons le cas d’un compte qui est défini par un code et un solde et sur
lequel, on peut verser un montant, retirer un montant et consulter le solde.
package metier;
public class Compte {
private int code;
private float solde;
public void verser(float mt){
solde=solde+mt;
}
public void retirer(float mt) throws Exception{
if(mt>solde) throw new Exception("Solde Insuffisant");
solde=solde-mt;
}
public float getSolde(){
return solde;
}
}

Utilisation de la classe Compte
 En faisant appel à la méthode retirer(), le compilateur signale que

cette dernière peut générer une exception de type Exception
 C’est une Exception surveillée. Elle doit être traitée par le programmeur
package pres;
import metier.Compte;
public class Application {
Compte cp=new Compte();
System.out.print("Montant à verser:");
float mt1=clavier.nextFloat();
cp.verser(mt1);
System.out.println("Solde Actuel:"+cp.getSolde());
System.out.print("Montant à retirer:");
cp.retirer(mt2); // Le comilateur signale l’Exception
}
}

Traiter l’exception
 Deux solutions :
 Soit utiliser le bloc try catch
try {
cp.retirer(mt2);
} catch (Exception e) {
}
 Ou déclarer que cette exception est ignorée dans la méthode main et dans ce
cas là, elle remonte vers le niveau supérieur. Dans notre cas la JVM.
Public static void main(String[] args) throws Exception {

Exécution de l’exemple Scénario 1
package pres; Montant à verser:5000

Solde Actuel:5000.0
import java.util.Scanner; Montant à retirer:2000
import metier.Compte; Solde Final=3000.0
Compte cp=new Compte(); Scénario 2
Montant à verser:5000
System.out.print("Montant à verser:"); Solde Actuel:5000.0
float mt1=clavier.nextFloat(); cp.verser(mt1); Montant à retirer:7000
Solde Insuffisant
Solde Final=5000.0
try {
cp.retirer(mt2);
}
System.out.println("Solde Final="+cp.getSolde());
}
}

Générer une exception non surveillée de type RuntimeException
package metier;
private int code;
solde=solde+mt;
}
public void retirer(float mt){
if(mt>solde) throw new RuntimeException("Solde Insuffisant");
solde=solde-mt;
}
return solde;
}
}

Utilisation de la classe Compte
 En faisant appel à la méthode retirer, le compilateur ne signale rien

 C’est une Exception non surveillée. On n’est pas obligé de la traiter pour que le
programme soit compilé
package pres;
import metier.Compte;
cp.verser(mt1);
cp.retirer(mt2); // Le comilateur ne signale rien
}
}

Personnaliser une exception

Personnaliser les exception métier.
 L’exception générée dans la méthode retirer, dans le cas ou le solde
est insuffisant est une exception métier.
 Il plus professionnel de créer une nouvelle Exception nommée
SoldeInsuffisantException de la manière suivante :
package metier;
public class SoldeInsuffisantException extends Exception {
public SoldeInsuffisantException(String message) {
super(message);
}
}
 En héritant de la classe Exception, nous créons une exception

surveillée.
 Pour créer une exception non surveillée, vous pouvez hériter de la
classe RuntimeException

Utiliser cette nouvelle exception métier
package metier;
private int code;
solde=solde+mt;
}
public void retirer(float mt) throws SoldeInsuffisantException{
if(mt>solde) throw new SoldeInsuffisantException("Solde Insuffisant");
solde=solde-mt;
}
return solde;
}
}

Application
package pres;
Scénario 1
import metier.Compte; Montant à verser:5000
Solde Actuel:5000.0
import metier.SoldeInsuffisantException;
Montant à retirer:2000
public class Application { Solde Final=3000.0
Scénario 2
System.out.print("Montant à verser:"); Solde Actuel:5000.0
float mt1=clavier.nextFloat(); Montant à retirer:7000
cp.verser(mt1); Solde Insuffisant
Solde Final=5000.0
float mt2=clavier.nextFloat(); Scénario 3
try { Montant à verser: gdfhgddghgdh
cp.retirer(mt2); Exception in thread "main"
java.util.InputMismatchException
} catch (SoldeInsuffisantException e) { at java.util.Scanner.throwFor(Scanner.java:840) at
java.util.Scanner.next(Scanner.java:1461)
System.out.println(e.getMessage()); at java.util.Scanner.nextFloat(Scanner.java:2319) at
} pres.Application.main(Application.java:9)
System.out.println("Solde Final="+cp.getSolde());
}
}

Améliorer l’application
 Dans le scénario 3, nous découvrons qu’une autre
exception non surveillée est générer dans le cas ou on
saisie une chaine de caractères et non pas un nombre.
 Cette exception est de type InputMismatchException,
générée par la méthode nextDouble() de la classe
Scanner.
 Nous devrions donc faire plusieurs catch dans la méthode
main

Application Scénario 1
package pres; Montant à verser:5000
import java.util.*; import metier.*; Solde Actuel:5000.0
Solde Final=3000.0
try { Scénario 2
Scanner clavier=new Scanner(System.in); Montant à verser:5000
Solde Actuel:5000.0
double mt1=clavier.nextDouble(); Solde Insuffisant
cp.verser(mt1); Solde Final=5000.0
System.out.print("Montant à retirer:"); Scénario 3
double mt2=clavier.nextDouble();
Montant à verser: gdfhgddghgdh
cp.retirer(mt2);
} Problème de saisie
catch (SoldeInsuffisantException e) { Solde Final=0.0
}
catch (InputMismatchException e) {
System.out.println("Problème de saisie");
}
System.out.println("Solde Final= :"+cp.getSolde());}

Un autre cas exceptionnel
 Supposons que l’on ne doit pas accepter un montant négatif

dans la méthode retirer.
 On devrait générer une exception de type
MontantNegatifException.
 Il faut d’abord créer cette nouvelle exception métier.

Le cas MontantNegatifEception
• L’exception métier MontantNegatifException

package metier;
public class MontantNegatifException extends Exception {
public MontantNegatifException(String message) {
super(message);
}
}
• Le methode retirer de la classe Compte

public void retirer(float mt)throws
SoldeInsuffisantException,MontantNegatifException{
if(mt<0) throw new MontantNegatifException("Montant "+mt+" négatif");
if(mt>solde) throw new SoldeInsuffisantException("Solde Insuffisant);
solde = solde –mt;
}

Application : Contenu de la méthode main
Scénario 1
try { Solde Actuel:5000.0
Scanner clavier=new Scanner(System.in); Montant à retirer:2000
Solde Final=3000.0
float mt1=clavier.nextFloat(); Scénario 2
cp.verser(mt1); Montant à verser:5000
System.out.println("Solde Actuel:"+cp.getSolde()); Solde Actuel:5000.0
System.out.print("Montant à retirer:"); Solde Insuffisant Solde
float mt2=clavier.nextFloat(); Final=5000.0
cp.retirer(mt2);
Scénario 3
}catch (SoldeInsuffisantException e) {
System.out.println(e.getMessage()); Montant à verser:5000
Solde Actuel:5000.0
}
Montant à retirer:-2000
catch (InputMismatchException e) { Montant -2000.0 négatif
System.out.println("Problème de saisie"); Solde Final=5000.0
}
catch (MontantNegatifException e) { Scénario 4
System.out.println(e.getMessage()); Montant à verser:azerty
} Problème de saisie
} Solde Final=0.0

Exemple 3 :
Projet Personne

Emballer une Exception dans une autre Exception
 Considérons le cas d’une classe Personne qui contient les attributs:

nom, âge, et sexe.
 On va simuler un recrutement des participants entreprises avec les
exigences suivantes:
o Les standards sont les gens entre 18 à 40 ans
o Accepter que les hommes
Les classes sont:
 Person: contient les attributs: nom, age et gender
 AgeUtils: Classe a une méthode statique pour évaluer l’âge
 AgeExcption: Exception Age
 TooOldException: Exception âge
 TooYoungException : Exception âge
 GenderException : Exception genre
 ValidateUtils: Classe a une méthode statique pour évaluer le candidat
 ValidateException: Exception évaluer les candidats
Emballer une Exception dans une autre Exception
Person
+ final MALE: String
+ final FEMALE: String
- name: String
Exception - gender: String
- age: int
+ Person(…)
+ Setters et Getters
GenderException AgeExcption ValidateExcption

ValidateUtils
+checkPerson(Person person):
TooYoungException TooOldExcption
AgeUtils
+ checkAge(age: int):

Etape 1: Lever une Exception sur l’age du candidat
Person
- name: String
- age: int
+ Person(…)

ValidateUtils
AgeUtils

Classes d’exceptions
Classe AgeException
package exception;
public class AgeException extends Exception {
public AgeException(String message) {
super(message);
}
}
Classe TooYoungException
package exception;
public class TooYoungException extends AgeException {
public TooYoungException(String message) {
super(message);
}
}
Classe TooOldException
package exception;
public class TooOldException extends AgeException {
public TooOldException(String message) {
super(message);
}

Classe metier: AgeUtils
package metier;
public class AgeUtils {
// 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
throw new TooYoungException("Age " + age + " too young");
} else if (age > 40) {
// Si l'âge est supérieur à 40, une exception sera jetée TooOldExcept
throw new TooOldException("Age " + age + " too old");
}
// Si l'âge est entre 18-40.
System.out.println("Age " + age + " OK!");
}
}

Classe Test: TestAgeExcepOne
package pres;
public class TestAgeExcepOne {
Scanner clavier = new Scanner(System.in);
// Commencer à recruter ...
System.out.println("Start Recruiting ...");
// Vérifier l'âge.
System.out.print("Check your Age :");
int age = clavier.nextInt();
AgeUtils.checkAge(age);
System.out.println("You pass!");

Classe Test: TestAgeExcepOne
package pres;
public class TestAgeExcepOne {
// Commencer à recruter ...
try {
} catch (TooYoungException e) {
// Faire quelque chose ici ...
System.out.println("You are too young, not pass!");
} catch (TooOldException e) {
// Faire quelque chose ici ...
System.out.println("You are too old, not pass!");
}
}
}
Classe Test: TestAgeExcepTwo
Nous allons attraper package pres;

les exceptions par le public class TestAgeExcepTwo {
biais des exceptions public static void main(String[] args) {
parent (classe super Scanner clavier = new Scanner(System.in);
exception). // Commencer à recruter ...
try {
} catch (AgeException e) {
// Si une exception se produit, type AgeException.
// Ce bloc catch sera exécuté.
System.out.println("You are invalid, not pass!");
}
}
}

Etape 2: Emballer une Exception dans une autre Exception
 On va simuler un maintenant les participants entreprises avec les

exigences suivantes:
o Les standards sont les gens entre 18 à 40 ans
o Les hommes seulement
Les classes à ajouter sont:
 Person: contient les attributs: nom, age et gender
 GenderException : Exception genre
 ValidateUtils: Classe a une méthode statique pour évaluer le candidat
 ValidateException: Exception évaluer les candidats

Etape 2: Lever une Exception sur l’age et sur le gender du candidat
Person
- name: String
- age: int
+ Person(…)

ValidateUtils
AgeUtils

Classe metier personne: Person
package metier;
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;
}
// Setters et Getters

Classe exceptions d’emballage
GenderException
Package exception;
// Exception de genre.
public class GenderException extends Exception {
public GenderException(String message) {

super(message);
}
}
 La classe ValidateException emballe une autre Exception
ValidateException
package exception;
public class ValidateException extends Exception {
// Emballer (wrap) Exception dans une autre Exception
public ValidateException(Exception e) {
super(e);
}
}

Classe metier: ValidateUtils
package metier;
public class ValidateUtils {
// Méthode pour vérifier une personne,
public static void checkPerson(Person person) throws ValidateException {
try {
// Valable si entre 18 et 40 ans
// Cette méthode peut lancer TooOldException, TooYoungException.
AgeUtils.checkAge(person.getAge());
// 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);
}
}
}

Classe TestEmballe
package pres;
public class TestWrapperException {
// Un candidat.
Person person = new Person("Marwa", Person.FEMALE, 26);
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());
}
}
}
}

Ameliorer un peuTestEmballe
public class TestWrapperException {
System.out.print("Recruting Name : ");
String name = clavier.next();
System.out.print("Check 1.Male, 2.Female? : ");
String gender = clavier.next("\\d{1,2}");
int choix = Integer.parseInt(gender);
switch (choix) {
case 1:
gender=Person.MALE; break;
case 2:
gender=Person.FEMALE; break;
default: break;
}
System.out.print("Check age : ");
Person person = new Person(name, gender, age);
try {
ValidateUtils.checkPerson(person);
} catch (ValidateException e) {
…..
}
}
}

Coursjava Lecon7 2022MY

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Coursjava Lecon7 2022MY

Transféré par

Droits d'auteur :

Formats disponibles

Programmation OO en Java

Chapitre VII. Gestion des exceptions

Dr. Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

public class ExceptionDemo {

public static void sayHello(String name){

public class Main {

public static void main(String[] args) {

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

 Souvent, un programme doit traiter des situations exceptionnelles qui n'ont

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Checked Unchecked Error

Cours Java 2022 Hassen Lazrag

 En Java, on peut classer les exceptions en deux catégories :

 Les exceptions non surveillées.

 Java oblige le programmeur à traiter les erreurs surveillées.

 Les erreurs non surveillées peuvent être traitées ou non. Et ne

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

On ne peut pas traiter les « Error »

RunTime Exception IOException AWTError VirtualMachineError

NullPointerException FileNotFoundException OutOfMemoryError

On doit traiter ces exceptions-ci

On n’est pas obligé de traiter ces exceptions-ci

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

 Dès qu'une exception est levée (instanciée),la

susceptible d'intercepter (saisir)

 Cette recherche s'effectue à partir du bloc

Cours Java 2022 Hassen Lazrag

public class ExceptionDemo {

public static void sayHello(String name){

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

public class ExceptionDemo {

public static void sayHello(String name){

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

public class ExceptionDemo {

public static void sayHello(String name){

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

<modificateurs> <type> < identificateur>( <liste param formels> )

Cours Java 2022 Hassen Lazrag

 Peut lancer une IOException  doit être attrapée

public void writeList()throws IOException,

Cours Java 2022 Hassen Lazrag

Cours Java 2022 Hassen Lazrag

 Considérons une application qui permet de :

 Faire appel à une fonction qui permet de calculer et de retourner a

Cours Java 2022 Hassen Lazrag

public class App1 {