Utilisation des contrôles conditionnels pour prévenir la division par zéro
Au lieu d'intercepter les exceptions après qu'elles se produisent, nous pouvons les empêcher de se produire en premier lieu en utilisant des contrôles conditionnels. Cette approche est souvent considérée comme plus efficace car les mécanismes de gestion des exceptions peuvent ajouter une surcharge à votre programme.
Créons un programme qui utilise des contrôles conditionnels pour éviter la division par zéro :
-
Dans le WebIDE, créez un nouveau fichier appelé ConditionalCheckDemo.java.
-
Copiez le code suivant dans le fichier :
public class ConditionalCheckDemo {
public static void main(String[] args) {
System.out.println("Starting the conditional check demonstration");
int numerator = 10;
int[] denominators = {5, 0, 2, 0, 4};
for (int denominator : denominators) {
int result = divideWithCheck(numerator, denominator);
System.out.println("Result of " + numerator + " / " + denominator + " = " + result);
}
System.out.println("Program completed successfully");
}
public static int divideWithCheck(int numerator, int denominator) {
// Check if denominator is zero before performing division
if (denominator == 0) {
System.out.println("Warning: Cannot divide by zero, returning -1 as a default value");
return -1;
} else {
return numerator / denominator;
}
}
}
- Ouvrez un terminal et compilez le programme Java :
javac ConditionalCheckDemo.java
- Exécutez le programme compilé :
java ConditionalCheckDemo
Vous devriez voir une sortie similaire à celle-ci :
Starting the conditional check demonstration
Result of 10 / 5 = 2
Warning: Cannot divide by zero, returning -1 as a default value
Result of 10 / 0 = -1
Result of 10 / 2 = 5
Warning: Cannot divide by zero, returning -1 as a default value
Result of 10 / 0 = -1
Result of 10 / 4 = 2
Program completed successfully
Dans cet exemple, nous vérifions si le dénominateur est nul avant d'effectuer la division. S'il est nul, nous retournons une valeur par défaut (-1) et affichons un message d'avertissement. Cette approche empêche l'ArithmeticException d'être levée en premier lieu.
Comparons les deux approches :
| Approche try-catch |
Approche par contrôle conditionnel |
| Gère les exceptions après qu'elles se produisent |
Empêche les exceptions de se produire |
| Utile lorsque les exceptions sont rares |
Utile lorsque les exceptions potentielles peuvent être prédites |
| Peut avoir une légère surcharge de performance |
Généralement plus efficace |
| Peut gérer plusieurs types d'exceptions |
Ne gère que les conditions spécifiques que vous vérifiez |
Les deux approches sont valables, et le choix entre elles dépend de vos exigences spécifiques :
-
Utilisez les contrôles conditionnels lorsque :
- Vous pouvez facilement prédire et vérifier les conditions d'erreur
- La performance est critique
- La condition devrait se produire fréquemment
-
Utilisez les blocs try-catch lorsque :
- La vérification de la condition rendrait le code plus complexe
- La condition d'erreur est rare
- Vous devez gérer plusieurs types d'exceptions
- La condition d'erreur pourrait se produire à divers endroits dans votre code
Maintenant, combinons les deux approches pour créer une solution plus robuste :
-
Créez un nouveau fichier appelé CombinedApproachDemo.java.
-
Copiez le code suivant dans le fichier :
public class CombinedApproachDemo {
public static void main(String[] args) {
System.out.println("Starting the combined approach demonstration");
int numerator = 10;
int[] denominators = {5, 0, 2, 0, 4};
for (int denominator : denominators) {
int result = divideWithCombinedApproach(numerator, denominator);
System.out.println("Result of " + numerator + " / " + denominator + " = " + result);
System.out.println("---------------");
}
System.out.println("Program completed successfully");
}
public static int divideWithCombinedApproach(int numerator, int denominator) {
// First approach: Check if denominator is zero
if (denominator == 0) {
System.out.println("Warning: Cannot divide by zero, returning -1 as a default value");
return -1;
}
// Second approach: Use try-catch as an additional safety net
try {
return numerator / denominator;
} catch (ArithmeticException e) {
// This should not happen if our conditional check is correct
// But it provides an extra layer of protection
System.out.println("Unexpected error occurred: " + e.getMessage());
return -999; // A different default value to distinguish from the conditional check
}
}
}
- Compilez et exécutez le programme :
javac CombinedApproachDemo.java
java CombinedApproachDemo
Vous devriez voir une sortie similaire à celle-ci :
Starting the combined approach demonstration
Result of 10 / 5 = 2
---------------
Warning: Cannot divide by zero, returning -1 as a default value
Result of 10 / 0 = -1
---------------
Result of 10 / 2 = 5
---------------
Warning: Cannot divide by zero, returning -1 as a default value
Result of 10 / 0 = -1
---------------
Result of 10 / 4 = 2
---------------
Program completed successfully
Cette approche combinée offre le meilleur des deux mondes. Elle utilise un contrôle conditionnel pour éviter l'exception dans les cas courants, et elle inclut également un bloc try-catch comme filet de sécurité pour intercepter tout problème inattendu.
Dans les applications du monde réel, ce style de programmation défensive aide à créer des logiciels plus robustes qui peuvent gérer les erreurs avec élégance et continuer à fonctionner même lorsque des situations inattendues surviennent.
