Erreurs logiques dans Java - les erreurs logiques

Les erreurs logiques dans la programmation Java peuvent être extrêmement difficiles à trouver car elles ne reflètent aucun type de problème de codage ou d'erreur dans l'utilisation des éléments du langage Java. Le code s'exécute parfaitement comme écrit: il n'effectue pas la tâche que vous attendiez.

Par conséquent, les erreurs logiques peuvent être les erreurs les plus difficiles à trouver. Vous devez passer du temps à parcourir votre code à la recherche d'une raison précise de l'erreur. Voici une liste des erreurs logiques courantes rencontrées par les développeurs Java:

• Utilisation d'une priorité d'opérateur incorrecte: L'ordre dans lequel Java interprète les opérateurs est important. Les applications produisent souvent un mauvais résultat car le développeur n'a pas inclus de parenthèses aux bons endroits.

  Par exemple, l'exemple suivant produit les sorties de 11, 13, 9 et 8 à partir des quatre variables, toutes en raison de l'emplacement (ou du manque) des parenthèses.

  public class OperatorError {public static void principal (String [] args) {// Crée des variables. int MyVar1 = 5 + 4 * 3/2; int MyVar2 = (5 + 4) * 3/2; int MyVar3 = (5 + 4) * (3/2); int MyVar4 = (5 + (4 * 3)) / 2; // Sort le résultat. Système. en dehors. println ("MyVar1:" + MyVar1 + "nMyVar2:" + MyVar2 + "nMyVar3:" + MyVar3 + "nMyVar4:" + MyVar4);}}
  

• Définir le mauvais compte: Probablement l'erreur logique la plus fréquente compte mal les choses. Les gens ont l'habitude de commencer le compte avec 1, et les ordinateurs commencent souvent le compte avec 0. Il n'est donc pas rare de constater que les applications sont exécutées avec précision, que cette tâche soit en boucle ou qu'elle fonctionne avec une collection d'éléments.

• En supposant qu'une condition est vraie quand ce n'est pas le cas: Les développeurs regarderont souvent l'instruction utilisée pour définir une condition et supposeront que l'instruction est vraie (ou fausse) sans vérifier la logique de la déclaration.

  L'utilisation d'une instruction ou lorsque vous vouliez vraiment utiliser une instruction et peut également causer des problèmes. La logique utilisée pour prendre des décisions cause beaucoup de problèmes à de nombreux développeurs, même expérimentés. Vérifiez toujours vos hypothèses pour les instructions conditionnelles.

• S'appuyer sur des nombres à virgule flottante pour un travail de précision: Vous ne pouvez pas supposer que les nombres à virgule flottante fourniront un nombre spécifique. Cela signifie que vous ne pouvez pas vérifier l'égalité d'un nombre à virgule flottante avec une valeur spécifique - vous devez plutôt utiliser une plage de valeurs pour effectuer la vérification. Les nombres à virgule flottante sont toujours une approximation en Java.

• S'appuyer sur des valeurs entières pour mesurer les valeurs: Les entiers sont parfaits pour compter les éléments car ils sont précis.Cependant, de nombreuses opérations mathématiques entières créent des résultats imprécis. Ceci est particulièrement vrai pour la division, parce que le reste est toujours laissé. (Le nombre est arrondi à l'inférieur.) Utilisez des valeurs à virgule flottante ou le type d'objet BigDecimal lorsque vous devez mesurer quelque chose et que la précision est importante.

• Mise au point d'un point-virgule: Il est possible de créer du code Java qui se compile et fonctionne parfaitement bien qu'il ait un point-virgule au mauvais endroit. Voici un exemple:

  public class ForLoopError {public static void principal (String [] args) {// Déclare la variable. int Count; // Crée la boucle. pour (compte = 1, compte <= 10, compte ++); {// Affiche le résultat. Système. en dehors. println ("Count is" + Count);}}}
  

  Notez que le point-virgule apparaît immédiatement après l'instruction for, plutôt qu'après le bloc de code comme il se doit. Au lieu d'imprimer des valeurs individuelles de Count, cet exemple imprime une seule phrase qui indique Count est 11.