java exceptions exception handling with examples
Ce didacticiel vidéo sur les exceptions Java explique tout sur la gestion des exceptions en Java. Vous en apprendrez davantage sur la hiérarchie des exceptions, les types, les méthodes de classe et plus:
Lorsque nous exécutons des programmes Java, le comportement normal ou le déroulement normal du programme est interrompu, en raison de certains événements inattendus.
Par exemple, nous ouvrons un fichier pour lire les données. Lorsque l'appel Open file est exécuté, nous trouvons que le fichier que nous essayons d'ouvrir est manquant. Cela entraîne l'interruption du déroulement normal du programme.
Cet événement qui affecte ou interrompt le déroulement normal du programme est appelé le ' Exception ».
=> Visitez ici pour découvrir la série de formations Java pour tous.
Voici un didacticiel vidéo sur la gestion des exceptions Java:
Ce que vous apprendrez:
Gestion des exceptions en Java
Lorsqu'une exception se produit dans le programme, l'exécution du programme est interrompue. Comme il s'agit d'une interruption brutale, le système génère un message et l'affiche. Le message généré par le système peut être cryptique comme certains codes ou illisible.
Ainsi, l'utilisateur normal doit comprendre pourquoi le programme a arrêté son exécution brusquement, il doit en connaître la raison. Les messages générés par le système à la suite d'une exception peuvent ne pas être utiles. En Java, nous pouvons gérer l'exception et fournir des messages significatifs à l'utilisateur sur le problème.
Cette gestion de l'exception, communément appelée 'Gestion des exceptions' est l'une des principales caractéristiques de la programmation Java.
Raisons de l'exception pour se produire
Nous pouvons avoir différentes raisons pour lesquelles des exceptions peuvent survenir. S'il s'agit d'une exception liée à l'entrée, la raison peut être que les données d'entrée sont incorrectes ou illisibles.
Si nous obtenons une exception pour les E / S de fichiers, il est fort possible que les fichiers que nous traitons n'existent pas. À un autre moment, il peut y avoir des erreurs telles que des problèmes de réseau, une imprimante non disponible ou ne fonctionne pas, etc.
Dans un programme, hormis les exceptions, nous obtenons également des erreurs. Ainsi, pour gérer efficacement les exceptions, nous devons être conscients des différences entre une erreur et une exception.
Une erreur indique un problème plus grave avec l'application et l'application ne doit pas tenter de l'attraper. Au contraire, l'exception est une condition que toute application raisonnable tentera d'attraper.
Ainsi, une erreur dans l'application est plus grave et les applications plantent lorsqu'elles rencontrent une erreur. Les exceptions, en revanche, se produisent dans le code et peuvent être gérées par le programmeur en fournissant des actions correctives.
Qu'est-ce que la gestion des exceptions?
La gestion des exceptions en Java est un mécanisme par lequel le flux normal de l'application est maintenu. Pour ce faire, nous utilisons un mécanisme puissant pour gérer les erreurs d'exécution ou les exceptions dans un programme.
Une séquence de code utilisée pour gérer l'exception est appelée «Gestionnaire d'exceptions». Un gestionnaire d'exceptions interroge le contexte au moment où l'exception s'est produite. Cela signifie qu'il lit les valeurs de variable qui étaient dans la portée lors de l'exception, puis restaure le programme Java pour continuer avec le flux normal.
Avantages de la gestion des exceptions
Le principal avantage de la gestion des exceptions est qu'il maintient le flux normal de l'application malgré l'occurrence d'une exception. Lorsqu'une exception se produit, le programme se termine généralement brusquement.
Avoir un gestionnaire d'exceptions dans un programme ne provoquera pas l'arrêt brutal du programme. Au lieu de cela, un gestionnaire d'exceptions s'assure que toutes les instructions du programme sont exécutées normalement et que le déroulement du programme ne s'arrête pas brusquement.
Hiérarchie des exceptions en Java
Le diagramme ci-dessous montre la hiérarchie des exceptions en Java. La classe java.lang.Throwable (descendant de la classe Object) est la classe racine de Java Exception. Les classes Exception et Error sont dérivées de cette classe.
La classe d'exception est la classe de base pour toutes les autres exceptions.
Vous trouverez ci-dessous une hiérarchie de la classe Exception en Java qui répertorie toutes les exceptions majeures dont un programmeur Java doit être conscient.
Classe d'exception en Java
Comme on le voit dans le diagramme hiérarchique, la classe Throwable a deux sous-classes directes, à savoir Exception et Error. Les exceptions provenant d'une source externe sont décrites dans la classe Exception.
La classe Exception déclare les constructeurs comme étant identiques à la classe Throwable et l'appel de chaque constructeur invoque également son homologue Throwable. La classe d'exception ne déclare pas ses méthodes, elle hérite des méthodes de classe Throwable.
Les constructeurs et méthodes utilisés par la classe Exception sont présentés ci-dessous.
Constructeurs
| Constructeur | Description |
|---|---|
| Exception publique () | Un constructeur par défaut qui construit une nouvelle exception avec le message comme null. |
| Exception publique (message de chaîne) | Constructeur pour construire une nouvelle exception avec le message donné. Dans ce cas, la cause n'est pas initialisée et un appel ultérieur à Throwable.initCause (java.lang.Throwable) peut être utilisé pour initialiser la cause. |
| Exception publique (message de chaîne, cause pouvant être rejetée) | Construit une nouvelle exception en utilisant un message et une cause donnés. |
| Exception publique (cause pouvant être rejetée) | Construit une nouvelle exception avec la cause donnée et un message donné par (cause == null? Null: cause.toString ()) (qui contient généralement la classe et le message détaillé de la cause). |
| Exception protégée (message de chaîne, cause pouvant être levée, boolean enableSuppression, boolean writableStackTrace) | Construit une nouvelle exception avec le message, la cause, la suppression (activé ou désactivé) et la trace de pile inscriptible (activée ou désactivée). |
Méthodes
| Prototype de méthode | Description |
|---|---|
| public String getMessage () | Obtenez un message détaillé sur l'exception qui s'est produite. |
| public Throwable getCause () | Obtenez la cause de l'exception représentée par un objet jetable |
| chaîne publique toString () | Concatène le nom de la classe avec le résultat de getMessage () et renvoie la chaîne résultante. |
| public void printStackTrace () | Imprime le résultat de toString () et le contenu de la trace de pile dans le flux de sortie d'erreur, System.err. |
| public StackTraceElement () getStackTrace () | Obtenez chaque élément de la trace de pile sous la forme d'un tableau. |
| public Throwable fillInStackTrace () | Remplissez la trace de pile avec la trace de pile actuelle. |
Exemple d'exception
Ensuite, nous présentons un programme Java pour illustrer un exemple d'exception de base. Ici, nous fournissons une variable de chaîne initialisée à une valeur nulle. Lorsque nous essayons d'imprimer cette variable, une exception est levée car la valeur String ne peut pas être nulle.
class Main { public static void main(String args()){ //declare a String variable and initialize it to null String myStr = null; //print the string System.out.println(myStr.length()); } } Production
Types d'exceptions en Java
Java prend en charge trois types d'exceptions:
- Exception vérifiée
- Exception non vérifiée
- Erreur
Dans cette section, nous aborderons les trois types ci-dessus.
# 1) Exception vérifiée
Certaines exceptions sont vérifiées au moment de la compilation lorsque le code est compilé. Ce sont des «exceptions vérifiées». Le programme Java génère une erreur de compilation lorsqu'il constate que le code à l'intérieur d'un programme est sujet aux erreurs.
Nous pouvons prendre en charge les erreurs de compilation générées par une exception vérifiée en gérant les exceptions en insérant le code dans un bloc try-catch ou en utilisant le mot clé throws.
Dans la hiérarchie des exceptions, la classe héritant directement de la classe Throwable comme IOException, ClassNotFoundException, etc. sont toutes vérifiées exception, à l'exception des classes RuntimeException et Error. Ce sont des exceptions non contrôlées.
Le programme Java suivant illustre les exceptions vérifiées, FileNotFoundException et IOException. Dans ce programme, nous essayons d'ouvrir un fichier inexistant et de le lire.
Comme le fichier n'existe pas, la méthode de fichier ouvert lève FileNotFoundException. Ensuite, lorsque nous essayons de lire le contenu du fichier et de fermer le fichier, les appels de méthodes lancent IOException.
import java.io.*; class Main { public static void main(String args()) { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }Production
Dans la sortie ci-dessus, comme le gestionnaire d'exceptions est absent, nous obtenons des erreurs de compilation pour les exceptions vérifiées.
Maintenant, fournissons une clause throws pour ce programme. Comme le parent de FileNotFoundException est IOException, nous allons simplement spécifier IOException après la clause throws.
import java.io.*; class Main { public static void main(String args()) throws IOException { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }Production
Comme le montre la sortie, lorsque nous gérons l'exception, elle fournit une sortie plus significative au lieu des erreurs de compilation.
# 2) Exception non vérifiée
Les exceptions non vérifiées sont les exceptions qui sont vérifiées au moment de l'exécution. Par conséquent, malgré les exceptions, une compilation de programmes réussira. La plupart des exceptions non vérifiées sont levées en raison des mauvaises données utilisées dans le programme.
Les classes qui héritent de «RuntimeException» sont des exceptions non vérifiées. Les exceptions telles que ArrayIndexOutofBounds Exception, ArithmeticException, NullPOinterException, etc. sont des exemples d'exceptions non vérifiées.
Le programme suivant illustre une exception non vérifiée à l'exécution provoquée par la division d'un nombre par zéro.
class Main { public static void main(String args()) { int num1=10; int num2=0; //divide both numbers and print the result int result=num1/num2; System.out.println(result); } }Production
Nous voyons que le programme est compilé avec succès et que l'exception ArithmeticException est lancée au moment de l'exécution.
Exemples d'exception non vérifiée:
- ArrayIndexOutOfBoundsException
- NullPointerException
- Exception d'argument illégal
- NumberFormatException
À part les deux exceptions ci-dessus, il existe quelques autres exceptions vérifiées, notamment:
- SQLException
- InvocationTargetExecption
# 3) Erreur
L'erreur est généralement une situation irréversible et irrémédiable dans un programme et lorsqu'une erreur se produit, les programmes se bloquent. Certains des exemples d'erreurs dans un programme sont OutOfMemoryError, AssertionError et VirtualMachineError, etc.
La classe d'erreur hérite de la classe Throwable. Erreur décrit une situation qui ne peut pas être gérée et entraîne le blocage d'un programme.
Examinons l'erreur OutOfMemory dans cette section comme exemple d'erreur.
Nous savons que tous les objets en Java sont alloués à l'aide du nouvel opérateur et sont stockés sur le tas. Lorsque le tas manque de mémoire, la machine virtuelle Java (JVM) ne peut pas allouer l'objet. Dans le même temps, le garbage collector ne peut pas libérer de mémoire. Cette situation donne lieu à l'erreur OutOfMemory.
L'OutOfMemoryError en Java ressemblera à ceci:
'exception in thread 'main' java.lang.outofmemoryerror: java heap space' La présence d'OutOfMemoryError dans un programme signifie que trop de données sont traitées ou que les objets sont conservés trop longtemps. Parfois, il peut également s'agir d'une bibliothèque tierce qui utilise de la mémoire.
Causes de OutOfMemoryError
# 1) Espace de tas Java
Si une application a trop de finaliseurs, les objets de classe ayant la méthode Finalize ne sont pas récupérés immédiatement par le garbage collector mais sont mis en file d'attente pour finalisation ultérieurement. Parfois, la finalisation ne peut pas suivre le rythme et la mémoire du tas est remplie, ce qui entraîne OutOfMemoryError.
Une autre raison pour OutOfMemoryError est que la taille de tas spécifiée peut être insuffisante pour l'application.
Le code suivant illustre l'OutOfMemoryError qui peut se produire en raison d'une taille de données énorme déclarée pour un tableau.
import java.util.*; public class Main { static List list = new ArrayList(); public static void main(String args()) throws Exception { Integer() array = new Integer(100000 * 100000); } } Production
# 2) Espace Permgen
La zone de génération permanente en mémoire peut également être épuisée et générer une erreur OutOfMemory.
La taille de la région PermGen est définie lors du lancement de la JVM. Si l'utilisateur ne définit pas la taille, la taille par défaut spécifique à la plate-forme est utilisée.
Bien que les deux ci-dessus soient généralement les principales causes de l'occurrence d'OutOfMemoryError, il peut y avoir d'autres causes telles que la taille du tableau dépassant la limite de la VM, etc.
Liste des exceptions en Java
Vous trouverez ci-dessous une liste des principales exceptions qui se produisent en Java. Nous avons fourni des exemples de programmation pour certaines de ces exceptions. Notez qu'il s'agit d'exceptions intégrées prises en charge par Java.
# 1) ArithmétiqueException: Les anomalies arithmétiques telles que la division par zéro donnent lieu à ArithmeticException.
Le programme ci-dessous montre l'occurrence d'ArithmeticException.
class Main { public static void main(String args()) { try { //define two numbers int num1 = 100, num2 = 0; int result = num1 / num2; // divide by zero //print the result System.out.println('Result = ' + result); } catch (ArithmeticException e) { System.out.println('ArithmeticException:Division by Zero'); } } }Production
# 2) ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException est levée lorsqu'un élément de tableau est accédé à l'aide d'un index illégal. L'index utilisé dépasse la taille du tableau ou est négatif.
# 3) ClassNotFoundException: Si la définition de classe n'est pas trouvée, l'exception ClassNotFoundException est déclenchée.
# 4) FileNotFoundException: FileNotFoundException est donné lorsque le fichier n'existe pas ou ne s'ouvre pas.
# 5) IOException: IOException est levée lorsque l'opération d'entrée-sortie échoue ou est interrompue.
# 6) Exception interrompue: Chaque fois qu'un thread est en cours de traitement, en veille ou en attente, il est interrompu en lançant InterruptedException.
# 7) NoSuchFieldException: Si une classe ne contient pas de champ ou de variable spécifié, elle lève NoSuchFieldException.
# 8) NoSuchMethodException: Lorsque la méthode en cours d'accès n'est pas trouvée, NoSuchMethodException est déclenchée.
# 9) NullPointerException: NullPointerException est déclenchée lorsqu'un objet nul est référencé. Il s'agit de l'exception la plus importante et la plus courante en Java.
# 10) NumberFormatException: Cette exception est déclenchée lorsqu'une méthode n'a pas pu convertir une chaîne en un format numérique.
# 11) RuntimeException: Toute exception qui se produit au moment de l'exécution est une RuntimeException.
# 12) StringIndexOutOfBoundsException: L'exception StringIndexOutOfBoundsException est levée par la classe String et indique que l'index dépasse la taille de l'objet String ou est négatif.
# 13) EOFException: EOFException fait partie du package java.io et est lancée lorsque la fin du fichier est atteinte et que le fichier est en cours de lecture.
# 14) IllegalArgumentException: IllegalArgumentException est levée lorsque des arguments illégaux ou non valides sont passés à la méthode. Par exemple, le mauvais format de données, une valeur nulle lorsque non-null est requis ou des arguments hors plage.
Le programme Java ci-dessous illustre l'exception IllegalArgumentException.
public class Main { int m; public static void setMarks(int marks) public static void main(String() args) { setMarks(45); setMarks(101); } }Production
Dans le programme ci-dessus, l'exception IllegalArgumentException est lancée dans le deuxième appel à la fonction setMarks où nous entrons les marques qui sont hors de portée (> 45).
# 15) InputMismatchException: InputMismatchException est levée lorsque la lecture d'entrée ne correspond pas à un modèle spécifié. Par exemple, si le programme attend un entier et lit un flottant, alors la InputMismatchException est déclenchée.
# 16) NoSuchElementException: NoSuchElementException est levée lorsque le prochain élément accédé n'existe pas.
Par exemple, dans Enumeration, la méthode nextElement () est utilisée pour accéder à l'élément suivant de l'énumération. Si l'élément n'existe pas, NoSuchElementException est levée. La plupart des collections Java lèvent cette exception.
Le programme ci-dessous le démontre.
import java.util.*; public class Main { public static void main(String() args) { Set hash_Set = new HashSet(); //create an empty hashSet. //This throws NoSuchElementException since hashSet is empty hash_Set.iterator().next(); } } Production
# 17) ConcurrentModificationException: ConcurrentModificationException est généralement levée par les classes Collection. Cette exception est levée lorsque les objets tentent de modifier une ressource simultanément.
Par exemple, un thread ne peut pas modifier une collection lorsqu'un autre thread y accède. Si nous autorisons deux threads, alors ces deux accéderont simultanément à la collection et il y aura des incohérences.
L'exemple suivant illustre l'exception ConcurrentModificationException.
import java.awt.List; import java.util.*; public class Main { public static void main(String() args) { ArrayList A_list = new ArrayList<>(); //add elements to the ArrayList A_list.add(10); A_list.add(20); A_list.add(30); Iterator it = A_list.iterator(); while (it.hasNext()) { Integer value = it.next(); System.out.println('ArrayList Value:' + value); if (value.equals(30)) A_list.remove(value); } } } Production
Dans le programme ci-dessus, pendant que ArrayList est en cours d'impression, nous essayons de supprimer un élément en même temps. Il s'agit de l'accès simultané et donc une exception est levée.
Exceptions personnalisées en Java
Jusqu'à présent, nous avons discuté de toutes les exceptions intégrées ou fournies par le langage Java. En dehors de ces exceptions, nous pouvons également définir nos propres exceptions. Celles-ci sont appelées exceptions personnalisées ou exceptions définies par l'utilisateur.
En utilisant des exceptions personnalisées, nous pouvons définir nos exceptions selon nos besoins.
L'exemple suivant montre l'exception personnalisée que nous avons définie pour une valeur Integer.
//custom exception definition class InvalidValueException extends Exception{ InvalidValueException(String s){ super(s); } } class Main{ static void validate(int int_val)throws InvalidValueException{ if(int_val<10) //value is valid if> 10 else throw exception throw new InvalidValueException('Invalid value'); else System.out.println('This is valid integer'); } public static void main(String args()){ try{ validate(9); }catch(Exception m){System.out.println('Exception occured: '+m);} System.out.println('Code after Exception'); } } Production
Questions fréquemment posées
Q # 1) Qu'entendez-vous par exception?
Répondre: Un événement qui se produit pendant l'exécution d'un programme et perturbe le déroulement normal de l'exécution du programme est appelé Exception. L'exception est indésirable et inattendue et peut se produire en raison de facteurs externes ou d'erreurs de programmation.
Q # 2) Quelle est la différence entre Erreur et Exception?
Répondre: Les exceptions sont les événements qui perturbent le déroulement normal du programme. Nous pouvons gérer les exceptions dans notre programme et continuer normalement avec le programme. Une erreur est un événement irrécupérable qui ne peut pas être géré et met fin au programme.
Q # 3) Qu'entendez-vous par gestion des exceptions?
Répondre: Le processus de spécification de la séquence d'étapes d'un programme pour gérer l'exception est appelé Gestion des exceptions. En fournissant des gestionnaires d'exceptions dans un programme, nous pouvons assurer le déroulement normal du programme.
Q # 4) Quels sont les avantages de la gestion des exceptions en Java?
Répondre: En utilisant la gestion des exceptions, nous pouvons maintenir le flux normal d'exécution d'une application. Nous pouvons également propager les erreurs dans la pile d'appels lorsque nous fournissons des gestionnaires d'exceptions.
Q # 5) À quoi sert la gestion des exceptions?
Répondre: Ne pas mettre fin au flux normal d'exécution d'une application est la principale utilité d'avoir des gestionnaires d'exceptions dans un programme. Sans les gestionnaires d'exceptions, le programme se terminera et le flux d'exécution normal sera interrompu lorsqu'une exception se produit.
Avec l'exception correctement gérée dans le programme, il peut continuer son exécution normale même lorsqu'une exception se produit.
Plus d'exemples d'exceptions
Une exception est un événement qui se produit pendant l'exécution du programme et qui perturbe l'exécution du programme. En raison de quoi le produit logiciel se terminera brusquement.
Lorsque cette exception se produit, Java crée un objet avec un message d'erreur et des informations sur la classe. C'est l'objet d'exception.
Pourquoi avons-nous besoin d'une exception en Java?
Classe ExcepDemo sans exception:
public class ExcepDemo { public static void main(String() args) { int i=5; int j=0; System.out.println(i/j); System.out.println('statement after division'); } } 
PRODUCTION:
Classe ExcepDemo avec gestion des exceptions:
public class ExcepDemo { public static void main(String() args) { // TODO Auto-generated method stub int i=5; int j=0; try { System.out.println(i/j); } catch(ArithmeticException ae) { System.out.println('wrong input'); } System.out.println('statement after division'); } } 
convertisseur youtube en mp3 téléchargement gratuit de haute qualité
PRODUCTION:
Essayez, attrapez et enfin bloquez:
- Une exception est gérée par le bloc try, catch.
- Les instructions qui peuvent conduire à des exceptions sont écrites à l'intérieur du bloc try.
- Lorsqu'une exception se produit, les instructions à l'intérieur du bloc catch seront exécutées. Si aucune exception ne se produit, le bloc catch ne sera pas exécuté.
- Indépendamment de l'exception survenue ou non, le bloc final sera exécuté.
Types d'exception
Exception non vérifiée:
Comme les exceptions non vérifiées peuvent être évitées par une programmation appropriée ( Par exemple. null pointeur Exception, Arithmetic Exception) n'auront pas été vérifiées par le compilateur. Une exception non cochée sera lancée lors de l'exécution.
Exception vérifiée:
- Checked Exception sera vérifiée par le compilateur et il est obligatoire de lever ou de gérer l'exception.
- Cette exception est utilisée pour séparer le code de gestion des erreurs du code normal.
- Toutes les exceptions vérifiées sont regroupées et cela est utile pour différencier les problèmes.
Exemple: java.io
import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class DemoExpChecked { public static void main(String() args) { try { File file=new File('input.txt'); BufferedReader br = new BufferedReader(new FileReader(file)) ; String content; while ((content=br.readLine())!=null) { System.out.println(content); } br.close(); } catch(IOException e) { e.printStackTrace(); } } } 
les erreurs
Une erreur peut se produire en raison d'erreurs logiques du programme ou de toute mémoire liée à un problème JVM.
Exemple: Erreur de mémoire hors limite ou erreur de dépassement de capacité de la pile.
Lancer et jeter
Le mot clé «Throw» est utilisé pour lever l'exception, tandis que le mot clé «throws» est utilisé pour déclarer l'exception.
Lancer un exemple de programme:
public class Demothrow { String content ; public void driving(String c) { this.content=c; if (content.isEmpty()) { throw new NullPointerException('content is empty'); } else { System.out.println('content=='+content); } } public static void main(String() args) { Demothrow dt=new Demothrow(); dt.driving(''); } } 
Lance un exemple de programme:
Les lancers sont utilisés pour indiquer que cette méthode lève cette exception particulière. Lorsque vous appelez cette méthode particulière, vous devez gérer cette exception.
public class DemoThrows { int i=2,j=0; public void checkmethod () throws ArithmeticException{ System.out.println(i/j); } public static void main(String() args) { DemoThrows d =new DemoThrows(); try { d.checkmethod(); } catch (ArithmeticException ae) { ae.printStackTrace(); } } } 
Points clés à noter:
- Les exceptions sont des événements anormaux qui se produisent pendant l'exécution du programme et qui affecteront le flux d'exécution.
- Une erreur est différente des exceptions. Exemple d'erreurs: Mémoire en panne.
- Les exceptions vérifiées sont vérifiées lors de la compilation et il est obligatoire de traiter cette exception vérifiée.
- Une exception non vérifiée se produit pendant l'exécution.
Conclusion
Ce didacticiel sur la gestion des exceptions en Java a présenté la définition des exceptions, la gestion des exceptions et la hiérarchie des exceptions en Java. Nous avons également discuté de la classe d'exception en Java qui fournit divers constructeurs et méthodes pour accéder aux exceptions.
Nous avons exploré une liste des exceptions courantes qui se produisent en Java et vu les exemples de programmation pour l'exception principale. Nous avons également discuté des erreurs majeures qui se produisent dans un programme Java ainsi que des types d'exceptions et d'exceptions personnalisées.
=> Consultez TOUS les didacticiels Java ici.
lecture recommandée
- Les 10 principales exceptions au sélénium et comment les gérer (code exact)
- Gestion des exceptions JDBC - Comment gérer les exceptions SQL
- Comment gérer l'exception dans les scripts SoapUI Groovy - Tutoriel SoapUI # 11
- Tutoriel Java String avec String Buffer et String Builder
- Déploiement Java: création et exécution d'un fichier JAR Java
- Threads Java avec méthodes et cycle de vie
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
- Modificateurs d'accès en Java - Tutoriel avec des exemples