3 types d’erreurs de programmation et comment les éviter
Les erreurs de programmation sont des défauts dans le fonctionnement des applications. Ils sont communément appelés "bugs", d'où le terme "débogage".
En tant que développeur, vous passerez beaucoup de temps à corriger des bogues. Un certain nombre d'erreurs que vous rencontrerez sont courantes, et les connaître vous aidera à les prévenir en premier lieu.
Voici ce que vous devez savoir sur ces trois types d'erreurs de programmation et comment vous pouvez vous en prémunir :
1. Erreurs d'exécution ou d'exécution
Ce sont des erreurs qui se produisent lors de l'exécution d'un programme (c'est-à-dire lors de l'exécution). Ils peuvent empêcher un programme de s'exécuter correctement ou même de ne pas s'exécuter du tout.
Les erreurs d'exécution fatales entraînent l'arrêt de l'exécution du programme tandis que les erreurs non fatales entraînent la fin de l'exécution, mais avec des résultats incorrects.
Une erreur d'exécution typique est une division par zéro erreur. La division par zéro est censée donner un résultat infini, mais malheureusement, nous n'avons pas encore trouvé de structure de données capable de stocker cette quantité de données.
Par conséquent, la division par zéro conduit à une exception arithmétique dans le compilateur Java.
2. Erreurs de logique
Les erreurs de logique sont dues à un raisonnement erroné. Il est important de noter que ces erreurs ne sont pas nécessairement dues à une « erreur » que vous avez commise. Ils peuvent se produire parce que vous n'avez pas envisagé un certain scénario d'exécution.
Ce sont les plus difficiles à manipuler. C'est parce que le code avec une erreur logique est un programme valide dans le langage dans lequel il est écrit. Par conséquent, il ne lancera pas d'erreur de compilateur. Le seul problème est qu'il produit des résultats incorrects.
Une erreur logique fatale entraînera l'arrêt de l'exécution du programme tandis qu'une erreur non fatale permettra à l'exécution du programme de continuer mais avec des résultats incorrects.
Une erreur logique courante est une erreur un par un. Cela se produit normalement lors de l'établissement d'une condition de continuation de boucle. Supposons que vous vouliez imprimer les cinq premiers nombres carrés.
Vous pourriez finir par écrire le code ci-dessous dans votre boucle for, qui ne donne que les quatre premiers de ces nombres.
for( int x=1; x<5; x++){ System.out.ln(x*x); }Pour éviter une telle erreur, vous pouvez utiliser à la place le signe <=. L'utilisation du signe inférieur ou égal à est plus intuitive et vous serez donc moins susceptible de mélanger vos opérations relationnelles.
Une autre erreur logique courante consiste à omettre les deux accolades d'une instruction de contrôle et pourtant le corps ci-dessous forme un bloc de code qui est sous son contrôle.
Regardez l'exemple ci-dessous. Il vérifie si un nombre aléatoire est pair ou impair, puis imprime une sortie.
import java.util.Random;
public class OddEven{
public static void main(String[] args) {
Random numberGenerator = new Random();
int randomNumber = numberGenerator.nextInt(10);
if ((randomNumber%2)==0)
System.out.println("Here is your lucky number :" + randomNumber);
System.out.println("The number "+ randomNumber +" that you got is even"); // line 11
}
}Remarquez la ligne 11. Elle s'exécutera toujours, que le nombre aléatoire que vous obtenez soit pair ou non. Ce serait bien sûr logiquement faux lorsque le nombre que vous avez obtenu est impair.
L'inclusion des deux instructions System.out.println entre accolades { } aurait évité cela.
Une autre erreur logique à surveiller est de ne pas fournir une condition de fin de boucle. Cela se traduira par une boucle infinie et votre programme ne terminera jamais l'exécution.
3. Erreurs de syntaxe ou de compilation
Il s'agit d'erreurs dues à des violations des règles du langage Java. Elles sont également appelées erreurs de compilation ou de compilation.
Ce sont les erreurs les plus faciles à gérer car votre compilateur les rapportera toujours. De nombreux compilateurs vont même de l'avant et vous indiquent la ligne de votre code sur laquelle se trouve l'erreur.
Tolérance aux pannes
Un moyen pratique de traiter les problèmes logiciels consiste à utiliser la tolérance aux pannes en incluant la gestion des exceptions. Vous pouvez utiliser les instructions try..catch pour y parvenir.
Pour continuer l'exécution du programme quelle que soit l'exception interceptée dans le bloc catch , utilisez l'instruction finally .
La syntaxe est :
try{ // Block to execute if there are no issues }
catch (Exception e){
// Block to handle issues found
}finally{ // Block to execute after catch
}Voir l'exemple de code ci-dessous :
import java.util.Random;
public class RandomNumbers{
public static void main(String[] args) {
Random numberGenerator = new Random();
try{
for (int counter = 10; counter<=100; counter++){
int randomNumber = numberGenerator.nextInt(10);
System.out.println(counter/randomNumber); } }
catch(Exception e){
System.out.println("Division by zero encountered!");
}
finally{
System.out.println("Infinite value got");}
}
}Le programme ci-dessus génère un nombre aléatoire entre zéro et 10, puis utilise ce nombre pour diviser une valeur de compteur entre 10 et 100. Si une division par zéro est rencontrée, le système détecte l'erreur et affiche un message.
Améliorez le codage
Il est recommandé d'ajouter des commentaires à votre code. Cela vous aidera à parcourir facilement vos fichiers lorsque vous avez un bogue. Une petite étape, mais très importante, pour développer des pratiques de codage solides.
Avec de bonnes pratiques de codage, vous devriez pouvoir éviter les erreurs de programmation courantes.