<?xml version="1.0" encoding="UTF-8"?>
<!-- French translation provided by David Cotton :) -->
<!-- Based on revision 1.307 of message.xml. -->
<MessageCollection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:noNamespaceSchemaLocation="messagecollection.xsd">
 <Plugin>
  <ShortDescription>Default FindBugs plugin</ShortDescription>
  <Details>
<![CDATA[
<p>Ce plugin contient tous les détecteurs standards de FindBugs.</p>
]]>
  </Details>
 </Plugin>


  <BugCategory category="CORRECTNESS">
    <Description>Droiture</Description>
    <Abbreviation>D</Abbreviation>
    <!-- Details subelement needed -->
  </BugCategory>

  <!-- BugCategory category="BAD_PRACTICE">
    <Description> </Description>
    <Abbreviation> </Abbreviation>
    <Details> </Details>
    </BugCategory -->

  <!-- BugCategory category="STYLE">
    <Description> </Description>
    <Abbreviation> </Abbreviation>
    <Details> </Details>
    </BugCategory -->

  <BugCategory category="PERFORMANCE">
    <Description>Performance</Description>
    <Abbreviation>P</Abbreviation>
    <!-- Details subelement needed -->
  </BugCategory>

  <BugCategory category="MALICIOUS_CODE">
    <Description>Vulnérabilité au code malveillant</Description>
    <Abbreviation>V</Abbreviation>
    <!-- Details subelement needed -->
  </BugCategory>

  <BugCategory category="MT_CORRECTNESS">
    <Description>Droiture en environnement multitâche</Description>
    <Abbreviation>M</Abbreviation>
    <!-- Details subelement needed -->
  </BugCategory>

  <BugCategory category="I18N">
    <Description>Internationalisation</Description>
    <Abbreviation>I</Abbreviation>
    <!-- Details subelement needed -->
  </BugCategory>


 <Detector class="edu.umd.cs.findbugs.detect.CheckImmutableAnnotation">
  <Details>
<![CDATA[
<p>Recherche les violations des règles pour les classes annotées comme <code>net.jcip.annotations.Immutable</code>.
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.VarArgsProblems">
  <Details>
<![CDATA[
<p>Recherche les problêmes liés aux arguments variables de Java 5.</p>
]]>
  </Details>
  </Detector>
  <Detector class="edu.umd.cs.findbugs.detect.NoteJCIPAnnotation">
  <Details>
<![CDATA[
<p>Enregistrement des annotations du package net.jcip.annotations package</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.NoteSuppressedWarnings">
  <Details>
<![CDATA[
<p>Supprime les alarmes marquées par l'annotation <code>edu.umd.cs.findbugs.annotations.NoteSuppressWarnings</code>.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.NoteAnnotationRetention">
  <Details>
<![CDATA[
<p>Enregistre la rétention d'annotations.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.Methods">
  <Details>
<![CDATA[
<p>Construit une liste de l'ensemble des méthodes définies dans les classes analysées, disponible pour être utilisée par d'autres détecteurs.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.CalledMethods">
  <Details>
<![CDATA[
<p>Construit une liste de l'ensemble des méthodes invoquées par les classes analysées, disponible pour être utilisée par d'autres détecteurs.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.ConfusionBetweenInheritedAndOuterMethod">
  <Details>
<![CDATA[
<p>Recherche les possibles confusions entre méthodes héritées et méthodes externes.</p>
]]>
  </Details>
 </Detector>
  <Detector class="edu.umd.cs.findbugs.detect.NoteCheckReturnValueAnnotations">
  <Details>
<![CDATA[
<p>Recherche les annotations permettant la vérification de la valeur renvoyée par une méthode.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.NoteNonNullAnnotations">
  <Details>
<![CDATA[
<p>Recherche les annotations <code>@NonNull</code> sur les méthodes, champs et paramètres. Ceci pourra être utilisé par le détecteur <i>FindNullDeref</i> pour générer des alarmes quand une valeur pouvant être à <code>null</code> est utilisée dans un contexte où seules des valeurs différentes de <code>null</code> devraient être utilisées.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.NoteUnconditionalParamDerefs">
  <Details>
<![CDATA[
<p>Analyse toutes les méthodes d'une application pour déterminer lesquelles déréférencent des paramètres de façon inconditionnelle. Ces informations sont disponibles pour une autre passe d'analyse recherchant les endrois où des valeurs à <code>null</code> sont transmises à ces méthodes.</p>
<p>C'est un détecteur lent</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.BadUseOfReturnValue">
  <Details>
<![CDATA[
<p>Recherche les cas où la valeur renvoyée par une méthode est ignorée après avoir été vérifiée non nulle.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InheritanceUnsafeGetResource">
  <Details>
<![CDATA[
<p>Détecte les utilisations de <code>this.getClass().getResource(...)</code>, qui peuvent donner des résultats inattendus si la classe est étendue par une classe d'un autre paquetage.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InfiniteRecursiveLoop">
  <Details>
<![CDATA[
<p>Détecte les boucles récursives infinies.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InfiniteLoop">
  <Details>
<![CDATA[
<p>Recherche les boucles infinies.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
  <Detector class="edu.umd.cs.findbugs.detect.VolatileUsage">
  <Details>
<![CDATA[
<p>Détecte l'utilisation erronée de champs volatiles.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.EmptyZipFileEntry">
  <Details>
<![CDATA[
<p>Détecte la création d'entrées vides dans un fichier Zip.</p>
<p>C'est un détecteur modérément rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.UncallableMethodOfAnonymousClass">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les classes internes anonymes qui définissent des méthodes qui tentent probablement, sans y parvenir, de surcharger une méthode de leur super classe.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.TestingGround">
  <Details>
<![CDATA[
<p>Ce détecteur est uniquement un point d'entrée pour tester de nouveaux détecteurs. Normalement, ce détecteur ne fait rien.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.DoInsideDoPrivileged">
  <Details>
<![CDATA[
<p>Recherche le code qui devrait être exécuté dans un block <code>doPrivileged</code>.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.ResolveAllReferences">
  <Details>
<![CDATA[
<p>Vérifie que tous les appels de références sont résolus.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.SwitchFallthrough">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les ordres switch dont un cas déborde sur le suivant.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindFieldSelfAssignment">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les champs qui s'alimentent avec leur propre valeur.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindNonShortCircuit">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les utilisations suspectes des opérateurs booléens binaires (<code>|</code> et <code>&amp;</code> au lieu de <code>||</code> et <code>&amp;&amp;</code>).</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.DontCatchIllegalMonitorStateException">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les blocs <code>try-catch</code> qui interceptent une <code>IllegalMonitorStateException</code>.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindFloatMath">
  <Details>
<![CDATA[
<p>Ce détecteur repère les utilisations d'opérations mathématiques en simple précision (<code>float</code>).</p>
<p>C'est un détecteur modérément rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.CloneIdiom">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les erreurs dans l'implémentation de l'idiome des classes <code>Cloneable</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.ComparatorIdiom">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les erreurs dans l'implémentation de l'idiome <code>Comparator</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.DroppedException">
  <Details>
<![CDATA[
<p>Ce détecteur détecte le code qui intercepte une exception sans la gérer.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.LoadOfKnownNullValue">
  <Details>
<![CDATA[
<p>Recherche les chargement de valeurs connues pour être à <code>null</code>.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.DumbMethodInvocations">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les paramètres erronés transmis à des méthodes (Ex : <code>substring(0)</code>).</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.DumbMethods">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels de méthodes inutiles, telle que le constructeur sans argument de <code>String</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindDoubleCheck">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les contrôles de verrou par double vérification.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindFinalizeInvocations">
  <Details>
<![CDATA[
<p>Ce détecteur repère les appels à <code>finalize()</code> et autres méthodes liées aux finaliseurs.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindHEmismatch">
  <Details>
<![CDATA[
<p>Ce détecteur repère les problèmes dans la définition des méthodes <code>hashCode()</code> et <code>equals()</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindNakedNotify">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>notify()</code> qui ne semblent pas changer l'état d'un objet modifiable.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindReturnRef">
  <Details>
<![CDATA[
<p>Ce détecteur repère les méthodes qui renvoient des données statiques modifiables.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindRunInvocations">
  <Details>
<![CDATA[
<p>Ce détecteur détecte les appels à <code>Thread.run()</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindSpinLoop">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les boucles qui tournent à vide en lisant un champ.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindTwoLockWait">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>wait()</code> avec deux (ou plus) verrous en suspens.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUnconditionalWait">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>wait()</code> qui ne sont pas dans une condition ou une boucle.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUninitializedGet">
  <Details>
<![CDATA[
<p>Ce détecteur repère les lectures de champs non initialisés dans les constructeurs.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUnsyncGet">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les méthodes <code>getXXX</code> et <code>setXXX</code> dont le <code>getXXX</code> n'est pas synchronisé alors que le <code>setXXX</code> l'est.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InitializationChain">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les dépendances circulaires potentielles dans l'initialisation des classes.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.IteratorIdioms">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les problèmes dans la définition des classes <code>Iterator</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.LockedFields">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les champs accédés de façon inconsistante par rapport aux verrous.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.EqStringTest">
  <Details>
<![CDATA[
<p>Ce détecteur repère les comparaisons d'objets <code>String</code> utilisant les opérateurs <code>==</code> ou <code>!=</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.MutableLock">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les synchronisations en lecture sur des champs modifiables.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.MutableStaticFields">
  <Details>
<![CDATA[
<p>Ce détecteur repère les champs statiques qui pourraient être modifiés par du code malveillant.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.Naming">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les méthodes au nom suspect.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.ReadReturnShouldBeChecked">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>InputStream.read()</code> ou <code>InputStream.skip()</code> qui ignorent la valeur renvoyée.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.SerializableIdiom">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les problèmes potentiels dans l'implémentation des classes <code>Serializable</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.StartInConstructor">
  <Details>
<![CDATA[
<p>Ce détecteur repère les constructeurs qui lancent des threads.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindBadForLoop">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les boucles incorrectes.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.UnreadFields">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les champs dont la valeur n'est jamais lue.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.WaitInLoop">
  <Details>
<![CDATA[
<p>Ce détecteur détecte les appels à <code>wait()</code> qui ne sont pas dans une boucle.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindNullDeref">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les endroits où une <code>NullPointerException</code> pourrait être déclenchée. Il recherche également les comparaisons redondantes de références avec <code>null</code>.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindOpenStream">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les objets contenant un flux IO qui ne semble pas être fermé dans tous les chemins d'exécution possibles.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.PreferZeroLengthArrays">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les méthodes qui renvoient soit un tableau, soit une référence explicite à <code>null</code>. Renvoyer un tableau de longueur nulle est généralement préférable dans ce cas au renvoi d'une référence à <code>null</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUselessControlFlow">
  <Details>
<![CDATA[
<p>Ce détecteur repère les pavés de contrôle du flux d'exécution qui n'ont aucun effet.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUnreleasedLock">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les verrous type JSR-166 (<code>java.util.concurrent</code>) qui sont acquis mais non libérés dans tous les chemins d'exécution possible d'une méthode.</p>
<p>C'est un détecteur modérément rapide.</p>
<p>Notez que pour utiliser ce détecteur vous devez avoir le paquetage <code>java.util.concurrent</code> dans le classpath (ou être en train d'analyser le paquetage lui-même).</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindRefComparison">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les endroits où deux valeurs sont comparées par référence avec l'opérateur <code>==</code> ou <code>!=</code>, et que la classe est d'un type (<code>java.lang.String</code> par exemple) tel que comparer les valeurs par références est généralement une erreur.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindMismatchedWaitOrNotify">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>wait()</code>, <code>notify()</code> ou <code>notifyAll()</code> qui ne semblent pas être effectués sur un objet verrouillé.</p>
<p>C'est un détecteur modérément rapide.</p>
<p><b>Ce détecteur est désactivé parce qu'il est toujours en cours de développement et produit trop de fausses alarmes.</b></p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindEmptySynchronizedBlock">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les blocks synchronisés vides.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindInconsistentSync2">
  <Details>
<![CDATA[
<p>Ce détecteur détecte les champs utilisés de manière inconsistante du point de vue des verrous.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindLocalSelfAssignment2">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les variables locales qui s'auto-alimentent.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.IncompatMask">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les expressions logiques binaires suspectes.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.LazyInit">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les initialisations paresseuses appliquées à des champs non volatiles.</p>
<p>C'est un détecteur modérément rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindJSR166LockMonitorenter">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les synchronisations ordinaires appliquées à des verrous type JSR166.</p>
<p>C'est un détecteur modérément rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUncalledPrivateMethods">
  <Details>
<![CDATA[
<p>Ce détecteur repère les méthodes privées qui ne sont jamais appelées.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.StringConcatenation">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les boucles contenant des concaténations de <code>String</code> utilisant <code>+</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InefficientToArray">
  <Details>
<![CDATA[
<p>Ce détecteur recherche le code qui transforme des <code>Collections</code> en tableaux en passant un tableau de longueur nulle à la méthode <code>toArray()</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InvalidJUnitTest">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les tests JUnit mal formés.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.BadlyOverriddenAdapter">
  <Details>
<![CDATA[
<p>Ce détecteur recherche le code qui étend une classe <code>Adapter</code> et surcharge une méthode <code>Listener</code> avec une signature erronée.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.BadResultSetAccess">
  <Details>
<![CDATA[
<p>Ce détecteur repère les appels aux méthodes <code>getXXX</code> ou <code>setXXX</code> d'un <code>ResultSet</code> avec un champ index à 0. Les indexes des champs <code>ResultSet</code> commençant à 1, c'est toujours une erreur.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.SuperfluousInstanceOf">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les tests de type effectués avec l'opérateur <code>instanceof</code> alors qu'une détermination statique serait possible.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.BadAppletConstructor">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les constructeurs d'applet invoquant des méthodes de l'applet mère non encore initialisées par <code>init()</code>. Ces appels feraient échouer le constructeur.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.UseObjectEquals">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>equals(java.lang.Object)</code> sur des tableaux ou des classes finales qui ne surchargent pas la méthode <code>equals</code> de la classe <code>Object</code>. Cela signifie que la sémantique de equals est la même que <code>==</code>, ce qui est probablement une erreur.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.SuspiciousThreadInterrupted">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels à <code>Thread.interrupted()</code> à partir d'un contexte non statique. Si l'appel provient de <code>Thread.currentThread().interrupted()</code>, l'exercice est inutile et il suffit d'utiliser <code>Thread.interrupted()</code>. Si l'appel provient d'un objet thread quelconque, c'est probablement une erreur puisque <code>interrupted()</code> est toujours appelé sur le thread en cours.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindSqlInjection">
  <Details>
<![CDATA[
<p>Ce détecteur utilise l'analyse de flôt de données pour rechercher les invocations de méthodes exécutées sur des commandes SQL (statement) dans lesquelles l'argument passé n'est pas une chaîne constante.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindDeadLocalStores">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les assignations de variables locales qui ne sont jamais lues.</p>
<p>C'est un détecteur moyennement rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindMaskedFields">
  <Details>
<![CDATA[
<p>Ce détecteur repère les champs du niveau classe qui sont masqués par des champs locaux dans les méthodes.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.WrongMapIterator">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les accès à la valeur d'une entrée <code>Map</code> en utilisant une clé récupérée à partir d'un itérateur sur <code>keySet</code>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InstantiateStaticClass">
  <Details>
<![CDATA[
<p>Ce détecteur recherche le code qui crée des objets basés sur des classes qui ne définissent que des méthodes statiques.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.RuntimeExceptionCapture">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les clauses <code>catch</code> qui interceptent <code>Exception</code>, alors qu'aucun code dans le bloc ne déclenche <code>Exception</code>.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindFloatEquality">
  <Details>
<![CDATA[
<p>Recherche les tests d'égalité en virgule flottante.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindUnsatisfiedObligation">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les flux I/O et les resources de bases de données qui ne sont pas correctement clos dans tous les chemins d'éxécution de la méthode.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.UnnecessaryMath">
  <Details>
<![CDATA[
<p>Ce détecteur recherche le code qui appelle les méthodes statiques <code>java.lang.Math</code> sur des valeurs constantes, dont le résultat est connu et constant. Il est plus rapide et parfois plus précis d'utiliser le résultat constant à la place.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindCircularDependencies">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les dépendances circulaires entre les classes.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.RedundantInterfaces">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les classes qui déclarent implémenter la même interface qu'une de leur super-classes. C'est redondant, puisque si la super-classe implémente l'interface, toutes les sous-classes l'implémentent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.MultithreadedInstanceAccess">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les problèmes potentiels avec l'emploi du cadre de travail <i>Struts</i>.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.PublicSemaphores">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les classes publiques qui synchronisent et utilisent <code>wait()</code>, <code>notify()</code> ou <code>notifyAll()</code> avec la référence <code>this</code>. Ceci expose l'implémentation de la synchronisation comme un artefact
public de la classe. Les objets utilisant une instance de cette classe pourraient l'utiliser également comme leur propre objet de synchronisation et provoquer des ravages dans l'implémentation de base.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.MethodReturnCheck">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les appels vers les méthodes où la valeur de retour est ignorée de façon douteuse.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.IDivResultCastToDouble">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les endroits où le résultat de la division de deux entiers est transtypée en nombre flottant à double précision. Souvent, l'intention initiale était de transtyper les opérandes avant de procéder à la division.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindBadCast">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les transtypages incorrects de références d'objets.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindBadCast2">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les erreurs de transtypages de références d'objets en utilisant une analyse des flux.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindNonSerializableStoreIntoSession">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les stockages de données non <code>Serializable</code> dans des sessions Http.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindNonSerializableValuePassedToWriteObject">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les obejts non <code>Serializable</code> transmis à la méthode <code>writeObject</code> d'un <code>ObjectOutput</code>.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.BadSyntaxForRegularExpression">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les expressions régulières à la syntaxe invalide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindPuzzlers">
  <Details>
<![CDATA[
<p>Ce détecteur recherche divers problèmes mineurs mentionnés par Joshua Bloch et Neal Gafter dans leur travail sur Programming Puzzlers.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindSleepWithLockHeld">
  <Details>
<![CDATA[
<p>Ce détecteur recher les appels à<code>Thread.sleep()</code> effectué alors que le verrou est tenu.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.DuplicateBranches">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les blocs <code>if/else</code> ou <code>switch</code> qui possèdent le même code pour leurs deux branches, rendant le test inutile. Ceci arraive souvent suite à un copier/coller entre les branches, entraînant une logique incorrecte pour l'une des branches.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.InefficientMemberAccess">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les classes internes qui écrivent dans une variable membre privée de leur classe englobante.
Un accesseur spécial est généré dans ce cas par la compilateur pour écrire dans cette variable. Dégrader la visiblité de cette variable en <code>protected</code> permettrait une écriture directe dans le champ.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.XMLFactoryBypass">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les allocations directes d'une implémentation des interfaces XML. Cela lie le code à une implémentation spécifique plutôt que de profiter du modèle de conception <i>Factory</i> disponible pour la création de ces objets.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindBadEqualsImplementation">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les implémentations de la méthode <code>equals(Object)</code> qui déréférence leur paramètre de façon inconditionnelle. Ceci contredit le contrat défini dans <code>java.lang.Object.equals()</code>, qui stipule que dans le cas d'un paramètre à <code>null</code> la méthode doit renvoyer <code>false</code>.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.UselessSubclassMethod">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les classes qui implémentent des méthodes de leur classe mère en se limitant transmettre les paramètres sans modifications aux méthodes mères. Ces méthodes surchargées peuvent simplement être supprimées.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.ConfusedInheritance">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les classes finales qui déclarent des membres protégés. L'utilisation de l'accès protégé est incorrect puisque ces classes ne peuvent pas être dérivées. L'accès devrait être modifié en <code>public</code> ou <code>private</code> pour représenter le véritable objectif du champ. Ceci est probablement causé par une modification dans le mode d'utilisation de la classe qui n'a pas été complétement pris en compte.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.QuestionableBooleanAssignment">
  <Details>
<![CDATA[
<p>Ce détecteur recherche les assignations simple de constantes booléennes à des variables dans les expressions conditionnelles.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.TrainNullReturnValues">
  <Details>
<![CDATA[
<p><code>TrainNullReturnValues</code> établit la liste des méthodes qui peuvent renvoyer <code>null</code> et la stocke dans un fichier. Le fichier produit est disponible pour d'autres passes d'analyse afin d'amméliorer la précision des détecteurs de déréférencement de <code>null</code>. Cette analyse préalable ne renvoie aucune alarme.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.TrainUnconditionalDerefParams">
  <Details>
<![CDATA[
<p><code>TrainUnconditionalParamDerefs</code> établit la liste des méthodes qui déréférencent leurs paramètres de façon inconditionnelle et la sauvegarde dans un fichier. Le fichier produit est disponible par la suite pour permettre d'augementer la précision des détecteurs de déréférencement de <code>null</code>. Cette analyse préalable ne renvoie aucune alarme.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.TrainFieldStoreTypes">
  <Details>
<![CDATA[
<p><code>TrainFieldStoreTypes</code> établit la liste des types stockés dans les champs et  la sauvegarde dans un fichier. Le fichier produit est disponible par la suite pour rendre les analyses de types plus précises.</p>
<p>C'est un détecteur lent.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.TrainNonNullAnnotations">
  <Details>
<![CDATA[
<p><code>TrainNonNullAnnotations</code> établit la liste des annotations <code>@NonNull</code> et <code>@PossiblyNull</code> et la sauvegarde dans un fichier.</p>
<p>C'est un détecteur rapide.</p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.CheckCalls">
  <Details>
<![CDATA[
<p>Ce détecteur n'est là que pour déboguer la résolution d'appels de méthodes de FindBugs.</p>
<p><b>Ne l'activez pas.</b></p>
]]>
  </Details>
 </Detector>
 <Detector class="edu.umd.cs.findbugs.detect.FindBugsSummaryStats">
  <Details>
<![CDATA[
<p>Ce détecteur rassemble juste des informations statistiques sur le processus d'analyse.</p>
]]>
  </Details>
 </Detector>
 <BugPattern type="SW_SWING_METHODS_INVOKED_IN_SWING_THREAD">
  <ShortDescription>Certaines méthodes Swing ne doivent être invoquées qu'à partir du thread Swing</ShortDescription>
  <LongDescription>L'appel de la méthode Swing {1} doit être effectué à partir du thread Swing</LongDescription>
  <Details>
<![CDATA[
<p>(<a href="http://java.sun.com/developer/JDCTechTips/2003/tt1208.html#1">Conseil technique JDC</a>) : les méthodes Swing <code>show()</code>, <code>setVisible()</code> et <code>pack()</code> créent les ressources associées à la fenêtre. En même temps que la création de ces ressources, le système crée le processus Swing de répartition de évènements.</p>
<p>Ceci pose problème car le processus de répartition des évènements peut notifier des écouteurs alors que <code>pack()</code> et <code>validate()</code> sont toujours en cours de traitement. Cette situation peut conduire à ce que deux processus essayent d'accèder en même temps au composant, ce qui est une faille sérieuse qui peut provoquer des interblocages et autres problèmes de synchronisation.</p>
<p>Un appel à <code>pack()</code> provoque l'initialisation du composant. Quand ils s'initialisent (sans être forcément visibles), les composants peuvent émettre des évènements vers le processus de répartition des évènements de Swing.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IL_INFINITE_LOOP">
  <ShortDescription>Boucle apparemment inifinie</ShortDescription>
  <LongDescription>Il y a apparemment une boucle infinie dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette boucle ne semble pas avoir un moyen de se terminer (autrement que, peut être, en déclenchant une exception).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IL_INFINITE_RECURSIVE_LOOP">
  <ShortDescription>Boucle récursive infinie</ShortDescription>
  <LongDescription>Il y a une boucle récursive infinie apparente dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode s'appelle elle-même sans condition. Cela semble indiquer une boucle récursive infinie qui se terminera sur un débordement de la pile.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IL_CONTAINER_ADDED_TO_ITSELF">
  <ShortDescription>Un conteneur est ajouté à lui-même</ShortDescription>
  <LongDescription>Un conteneur est ajouté à lui-même dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Un conteneur est ajouté à lui-même. Il en résulte que le calcul du code de hachage de cet ensemble provequera une <code>StackOverflowEception</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="VO_VOLATILE_REFERENCE_TO_ARRAY">
  <ShortDescription>Une référence volatile à un tableau ne traite pas les éléments du tableau comme volatiles</ShortDescription>
  <LongDescription>{1} est une référence volatile à un tableau ; les éléments du tableau ne sont pas volatiles.</LongDescription>
  <Details>
<![CDATA[
<p>Ceci déclare une référence volatile à un tableau, ce qui n'est peut-être pas ce que vous voulez. Avec une référence volatile à un tableau, les lectures et écritures de la référence au tableau sont traitées comme volatiles, mais les éléments ne sont pas volatiles. Pour obtenir des éléments volatiles, vous devez utiliser l'une des classes de tableaux atomiques de <code>java.util.concurrent</code> (inclus dans Java 5.0).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UI_INHERITANCE_UNSAFE_GETRESOURCE">
  <ShortDescription>L'utilisation de GetResource peut-être instable si la classe est étendue</ShortDescription>
  <LongDescription>L'utilisation de GetResource dans {1} peut-être instable si la classe est étendue</LongDescription>
  <Details>
<![CDATA[
<p>Appeler <code>this.getClass().getResource(...)</code> peut rendre des résultats différents de ceux attendus si la classe est étendue par une classe d'un autre paquetage.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="TESTING">
  <ShortDescription>Test</ShortDescription>
  <LongDescription>Alarme déclenchée dans les tests de {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette alarme n'est générée que par les nouveaux détecteurs de bogues, à l'implémentation incomplète.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="AM_CREATES_EMPTY_ZIP_FILE_ENTRY">
  <ShortDescription>Crée une entrée de fichier Zip vide</ShortDescription>
  <LongDescription>Entrée de fichier Zip vide créée dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code appelle <code>putNextEntry()</code>, immédiatement suivi d'un appel à <code>closeEntry()</code>. Ceci crée une entrée de fichier Zip vide. Le contenu des entrées devrait être écrit dans le fichier Zip entre les appels à <code>putNextEntry()</code> et <code>closeEntry()</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="AM_CREATES_EMPTY_JAR_FILE_ENTRY">
  <ShortDescription>Crée une entrée de fichier Jar vide</ShortDescription>
  <LongDescription>Entrée de fichier Jar vide créée dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code appelle <code>putNextEntry()</code>, immédiatement suivi d'un appel à <code>closeEntry()</code>. Ceci crée une entrée de fichier Jar vide. Le contenu des entrées devrait être écrit dans le fichier Jar entre les appels à <code>putNextEntry()</code> et <code>closeEntry()</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IMSE_DONT_CATCH_IMSE">
  <ShortDescription>Interception douteuse d'une IllegalMonitorStateException</ShortDescription>
  <LongDescription>Interception douteuse d'une IllegalMonitorStateException dans {1}</LongDescription>
  <Details>
<![CDATA[
<p><code>IllegalMonitorStateException</code> n'est généralement déclenchée que dans le cas d'une faille dans la conception du code (appeler <code>wait()</code> ou <code>notify()</code> sur un objet dont on ne possède pas le verrou).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FL_MATH_USING_FLOAT_PRECISION">
  <ShortDescription>La méthode effectue des calculs en simple précision (float)</ShortDescription>
  <LongDescription>{1} effectue des calculs en simple précision (float)</LongDescription>
  <Details>
<![CDATA[
<p>La méthode effectue des opérations mathématiques en simple précision (<code>float</code>). Les <code>float</code> peuvent être très imprécis. Par exemple, 16777216.0f +1.0f = 16777216.0f. Envisagez d'utiliser la double précision à la place.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="CN_IDIOM">
  <ShortDescription>La classe implémente Cloneable mais ne définit et n'utilise pas la méthode clone()</ShortDescription>
  <LongDescription>La classe {0} implémente Cloneable mais ne définit et n'utilise pas la méthode clone()</LongDescription>
  <Details>
<![CDATA[
<p>La classe implémente <code>Cloneable</code> sans définir ou utiliser la méthode <code>clone()</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="CN_IDIOM_NO_SUPER_CALL">
  <ShortDescription>La méthode clone() n'appelle pas super.clone()</ShortDescription>
  <LongDescription>La méthode clone() {1} n'appelle pas super.clone()</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une méthode <code>clone()</code> qui n'appelle pas <code>super.clone()</code>, et n'est pas finale. Si cette classe ("<i>A</i>") est étendue par une classe fille ("<i>B</i>"), et que la classe fille <i>B</i> appelle <code>super.clone()</code>, alors il est probable que la méthode <code>clone()</code> de <i>B</i> retournera un objet de type <i>A</i>, ce qui viole le contrat standard de <code>clone()</code>.</p>
<p>Si toutes les méthodes <code>clone()</code> appellent <code>super.clone()</code>, elles ont alors la garantie d'utiliser <code>Object.clone()</code>, qui retourne toujours un objet du type correct.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DE_MIGHT_DROP">
  <ShortDescription>La méthode peut déclencher une exception</ShortDescription>
  <LongDescription>{1} peut déclencher {3}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode peut déclencher une exception. En général, les exceptions doivent être gérées ou transmises hors de la méthode.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DE_MIGHT_IGNORE">
  <ShortDescription>La méthode peut ignorer une exception</ShortDescription>
  <LongDescription>{1} peut ignorer {3}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode peut ignorer une exception. En général, les exceptions doivent être gérées ou transmises hors de la méthode.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DP_DO_INSIDE_DO_PRIVILEGED">
  <ShortDescription>Méthode invoquée alors qu'elle ne devrait l'être qu'à partir d'un block doPrivileged</ShortDescription>
  <LongDescription>{1} invoque {2}, qui ne devrait être invoquée qu'à partir d'un block doPrivileged</LongDescription>
  <Details>
<![CDATA[
<p>Ce code invoque une méthode qui nécessite un test de sécurité sur les permissions. Si ce code, bien qu'ayant les droits suffisants, peut être invoqué par du code n'ayant pas les droits requis l'appel doit alors être effectué à l'intérieur d'un block <code>doPrivileged</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED">
  <ShortDescription>Les chargeurs de classes ne doivent être créés qu'à partir de block doPrivileged</ShortDescription>
  <LongDescription>{1} créé un chargeur de classes {2} en dehors d'un block doPrivileged</LongDescription>
  <Details>
<![CDATA[
<p>Ce code créé un chargeur de classes, ce qui nécessite un test de sécurité. Même si ce code possède des droits suffisants, la création du chargeur de classes devrait être effectuée dans un block <code>doPrivileged</code> au cas ou il serait appelé par du code ne possédant pas les droits requis.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="JCIP_FIELD_ISNT_FINAL_IN_IMMUTABLE_CLASS">
  <ShortDescription>Les champs d'une classe immuable devraient être finaux.</ShortDescription>
  <LongDescription>{1} devrait être final puisque {0} est marquée comme Immutable.</LongDescription>
  <Details>
<![CDATA[
La classe est annotée avec <code>net.jcip.annotations.Immutable</code>, et la règle liée à cette annotation réclame que tous les champs soient marqués <code>final</code>.
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_ANNOTATION_IS_NOT_VISIBLE_TO_REFLECTION">
  <ShortDescription>La réflexion ne peut pas être utilisée pour vérifier la présence d'une annotation avec la rétention par défaut</ShortDescription>
  <LongDescription>{1} utilise la réflexion pour vérifier la présence d'une annotation qui a la rétention par défaut</LongDescription>
  <Details>
<![CDATA[
<p>A moins qu'une annotation ait elle même été annotée avec une <code>@Retention</code> différente de la rétention "source uniquement" par défaut, l'annotation n'est pas conservée dans le fichier .class et ne peut pas être utilisée par réflexion (par exemple avec la méthode <code>isAnnotationPresent()</code>).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_EXIT">
  <ShortDescription>La méthode invoque System.exit(...)</ShortDescription>
  <LongDescription>{1} invoque System.exit(...), qui stoppe toute la JVM</LongDescription>
  <Details>
<![CDATA[
<p>Invoquer <code>System.exit()</code> arrête toute la JVM. Cela ne doit être fait que lorsque c'est nécessaire. De tels appels rendent difficile ou impossible l'invocation de votre code par d'autre code. Envisagez de déclencher une <code>RuntimeException</code> à la place.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_RUN_FINALIZERS_ON_EXIT">
  <ShortDescription>Méthode invoquant runFinalizersOnExit, l'une des plus dangeureuses méthodes des librairies Java</ShortDescription>
  <LongDescription>{1} invoque runFinalizersOnExit, l'une des plus dangeureuses méthodes des librairies Java</LongDescription>
  <Details>
<![CDATA[
<p>N'appelez jamais <code>System.runFinalizersOnExit</code> ou <code>Runtime.runFinalizersOnExit</code> pour quelque raison que ce soit : elles font partie des méthodes les plus dangeureuses des librairies Java</p>
<p>Joshua Bloch</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_STRING_CTOR">
  <ShortDescription>La méthode invoque le constructeur inutile String(String) ; utilisez juste l'argument</ShortDescription>
  <LongDescription>{1} invoque le constructeur inutile String(String) ; utilisez juste l'argument</LongDescription>
  <Details>
<![CDATA[
<p>Utiliser le constructeur <code>java.lang.String(String)</code> gaspille de la mémoire puisque l'objet ainsi construit serait fonctionnellement identique à la chaîne passée en paramètre. Utilisez juste la chaîne en argument directement.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_STRING_VOID_CTOR">
  <ShortDescription>La méthode invoque le constructeur inutile String() ; utilisez juste ""</ShortDescription>
  <LongDescription>{1} invoque le constructeur inutile String() ; utilisez juste ""</LongDescription>
  <Details>
<![CDATA[
<p>Créer un nouveau objet <code>java.lang.String</code> en utilisant le constructeur sans argument gaspille de la mémoire parce que l'objet ainsi créé serait fonctionnellement identique à la constante de chaîne vide "". Java garantie que les chaînes constantes identiques seront représentées par le même objet <code>String</code>. C'est pourquoi vous devriez directement utiliser la constante de chaîne vide.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_STRING_TOSTRING">
  <ShortDescription>La méthode appel toString() sur un objet String ; utilisez directement l'objet String</ShortDescription>
  <LongDescription>La méthode {1} appel toString() sur un objet String ; utilisez directement l'objet String</LongDescription>
  <Details>
<![CDATA[
<p>Appeler <code>String.toString()</code> est juste une opération redondante. Utilisez directement l'objet <code>String</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_GC">
  <ShortDescription>Ramasse-miettes explicite ; extrêmement douteux sauf dans du code de banc d'essai</ShortDescription>
  <LongDescription>{1} force le déclenchement du ramasse-miettes ; extrêmement douteux sauf dans du code de banc d'essai</LongDescription>
  <Details>
<![CDATA[
<p>Le code appelle explicitement le ramasse-miettes. Mis à part l'emploi spécifique dans un banc d'essai, c'est très douteux.</p>
<p>Dans le passé, les cas où des personnes ont explicitement invoqué le ramasse-miettes dans des méthodes telles que <code>close()</code> ou <code>finalize()</code> ont creusés des gouffres dans les performances. Le ramasse-miettes peut-être très coûteux. Toute situation qui force des centaines ou des milliers de ramasse-miettes mettra à genoux une machine.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_BOOLEAN_CTOR">
  <ShortDescription>La méthode invoque le constructeur inutile Boolean() ; utilisez Boolean.valueOf(...) à la place</ShortDescription>
  <LongDescription>{1} invoque le constructeur inutile Boolean() ; utilisez Boolean.valueOf(...) à la place</LongDescription>
  <Details>
<![CDATA[
<p>Créer de nouvelles instances de <code>java.lang.Boolean</code> gaspille la mémoire puisque les objets <code>Boolean</code> sont immuables et qu'il n'y a que deux valeurs utiles de ce type. Utilisez à la place la méthode <code>Boolean.valueOf()</code> pour créer des objets <code>Boolean</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_CONVERT_CASE">
  <ShortDescription>La méthode appelle les String.toUpperCase() ou String.toLowerCase ; utilisez plutôt la version paramètrée par une Locale</ShortDescription>
  <LongDescription>La méthode {1} invoque String.toUpperCase() ou String.toLowerCase ; utilisez plutôt la version acceptant une Locale</LongDescription>
  <Details>
<![CDATA[
<p>Une chaîne est mise en majuscules ou minuscules en fonction de jeu de caractères par défaut de la machine. Ceci peut entraîner des conversions erronées sur les caractères internationaux. Utilisez <code>String.toUpperCase(Locale l)</code> ou <code>String.toLowerCase(Locale l)</code> à la place.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_BOXED_PRIMITIVE_TOSTRING">
  <ShortDescription>Méthode allouant une primitive boxed pour appeler toString</ShortDescription>
  <LongDescription>La méthode {1} alloue une primitive boxed juste pour appeler toString</LongDescription>
  <Details>
<![CDATA[
<p>Une primitive "boxed" est allouée juste pour appeler <code>toString()</code>. Il est plus efficace de simplement utiliser la forme statique de <code>toString</code> qui accepte la valeur primitive. Donc,</p>
  <table>
     <tr><th>Remplacer...</th><th>Avec...</th></tr>
     <tr><td><code>new Integer(1).toString()</code></td><td><code>Integer.toString(1)</code></td></tr>
     <tr><td><code>new Long(1).toString()</code></td><td><code>Long.toString(1)</code></td></tr>
     <tr><td><code>new Float(1.0).toString()</code></td><td><code>Float.toString(1.0)</code></td></tr>
     <tr><td><code>new Double(1.0).toString()</code></td><td><code>Double.toString(1.0)</code></td></tr>
     <tr><td><code>new Byte(1).toString()</code></td><td><code>Byte.toString(1)</code></td></tr>
     <tr><td><code>new Short(1).toString()</code></td><td><code>Short.toString(1)</code></td></tr>
     <tr><td><code>Boolean.valueOf(true).toString()</code></td><td><code>Boolean.toString(true)</code></td></tr>
  </table>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_NEW_FOR_GETCLASS">
  <ShortDescription>Méthode allouant un objet juste pour obtenir la classe</ShortDescription>
  <LongDescription>La méthode {1} alloue un objet juste pour obtenir la classe correspondante</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode alloue un objet juste pour appeler sa méthode <code>getClass()</code> afin d'obtenir l'objet <code>Class</code> correspondant. Il est plus simple d'accèder directement à la propriété <code>.class</code> de la classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_MONITOR_WAIT_ON_CONDITION">
  <ShortDescription>Wait() appelé sur une Condition</ShortDescription>
  <LongDescription>Wait() appelé sur une Condition dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>wait()</code> sur un objet <code>java.util.concurrent.locks.Condition</code>. L'attente d'une <code>Condition</code> devrait être faite en utilisant l'une des méthodes <code>await()</code> définies dans l'interface <code>Condition</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RV_01_TO_INT">
  <ShortDescription>Les valeurs aléatoires entre 0 et 1 sont réduites à l'entier 0</ShortDescription>
  <LongDescription>L'utilisation de la méthode {1} génère une valeur aléatoire entre 0 et 1, puis la réduit à la valeur entière 0</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur aléatoire comprise entre 0 et 1 est réduite à la valeur entière 0. Vous souhaitez probablement multiplier cette valeur aléatoire par quelque chose avant de la réduire à un entier, ou utiliser la méthode <code>Random.nextInt(n)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_NEXTINT_VIA_NEXTDOUBLE">
  <ShortDescription>Utiliser la méthode nextInt de Random plutôt que nextDouble pour générer un entier aléatoire</ShortDescription>
  <LongDescription>La méthode {1} utilise la méthode nextDouble de Random pour générer un entier aléatoire : utiliser nextInt est plus efficace</LongDescription>
  <Details>
<![CDATA[
<p>Si <code>r</code> est un <code>java.util.Random</code>, vous pouvez générer un nombre aléatoire entre 0 et n-1 en utilisant <code>r.nextInt(n)</code> plutôt que <code>(int)(r.nextDouble() * n)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SQL_NONCONSTANT_STRING_PASSED_TO_EXECUTE">
  <ShortDescription>Une chaîne non constante est passée à la méthode execute d'une commande SQL</ShortDescription>
  <LongDescription>La méthode {1} passe une chaîne non constante à la méthode execute d'une commande SQL (statement)</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode invoque la méthode <code>execute</code> d'une commande SQL (statement) avec une chaîne qui semble générée dynamiquement. Préférer la préparation de la commande avec un <code>PreparedStatement</code>, c'est plus efficace et bien moins vulnérable aux attaques par injection SQL (insertion de code SQL malveillant au sein d'une requête).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SQL_PREPARED_STATEMENT_GENERATED_FROM_NONCONSTANT_STRING">
  <ShortDescription>Une requète est préparée à partir d'une chaine non constante</ShortDescription>
  <LongDescription>Une requète est préparée à partir d'une chaine non constante dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code créé une requète SQL préparée à partir d'une chaine non constante. Les données qui permettent de construire cette chaine venant de l'utilisateur, elles pourraient, sans vérification, servir à faire de l'injection de SQL et ainsi modifier la requète afin qu'elle produise des résultats inattendus et indésirables.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DM_USELESS_THREAD">
  <ShortDescription>Thread créé avec la méthode run vide par défaut</ShortDescription>
  <LongDescription>La méthode {1} crée un thread utilisant la méthode run vide par défaut</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode crée un thread sans spécifier de méthode <code>run</code>, soit par dérivation de la classe <code>Thread</code>, soit en transmettant un objet <code>Runnable</code>. Ce thread ne fait donc rien sauf perdre du temps.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DC_DOUBLECHECK">
  <ShortDescription>Possible double vérification d'un champ</ShortDescription>
  <LongDescription>Possible double vérification sur {2} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient peut-être une instance de verrou par double vérification. Cet idiome n'est pas correct vis-à-vis de la sémantique du modèle de mémoire Java. Pour plus d'informations, cf. la page <a href="http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html">http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html</a>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FI_PUBLIC_SHOULD_BE_PROTECTED">
  <ShortDescription>Un finaliseur devrait être protégé, pas public</ShortDescription>
  <LongDescription>{1} est public ; il devrait être protégé</LongDescription>
  <Details>
<![CDATA[
<p>La méthode <code>finalize()</code> d'une classe devrait avoir un accès protégé, pas public.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FI_EMPTY">
  <ShortDescription>Un finaliseur vide devrait être supprimé</ShortDescription>
  <LongDescription>{1} est vide et devrait être supprimé</LongDescription>
  <Details>
<![CDATA[
<p>Les méthodes <code>finalize()</code> vides sont inutiles, donc elles devraient être supprimées.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FI_NULLIFY_SUPER">
  <ShortDescription>Un finaliseur rend inutile celui de sa super-classe</ShortDescription>
  <LongDescription>{1} rend inutile {2}.finalize() ; est-ce voulu ?</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode <code>finalize()</code> vide rend explicitement inutile tout finaliseur défini dans les super-classes. Toute action définie dans un finaliseur d'une superclasse sera ignorée. A moins que cela ne soit voulu, supprimer cette méthode.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FI_USELESS">
  <ShortDescription>Le finaliseur ne fait rien sauf appeler celui de la super-classe</ShortDescription>
  <LongDescription>{1} ne fait rien d'autre qu'appeler super.finalize() ; supprimez le</LongDescription>
  <Details>
<![CDATA[
<p>La seule chose que cette méthode <code>finalize()</code> fait est d'appeler la méthode <code>finalize()</code> de la super-classe, ce qui la rend redondante. Supprimez la.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FI_MISSING_SUPER_CALL">
  <ShortDescription>Le finaliseur n'appelle pas le finaliseur de la super-classe</ShortDescription>
  <LongDescription>{1} oublie d'appeler super.finalize(), donc {2}.finalize() n'est jamais appelé</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode <code>finalize()</code> n'appelle pas la méthode <code>finalize()</code> de sa classe mère ; donc toutes les actions définies au niveau de la classe mère seront ignorées. Ajoutez un appel à <code>super.finalize()</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FI_EXPLICIT_INVOCATION">
  <ShortDescription>Invocation explicite d'un finaliseur</ShortDescription>
  <LongDescription>{1} invoque explicitement {2}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un appel explicite à la méthode <code>finalize()</code> d'un objet. Les méthodes <code>finalize()</code> étant sensées n'être appelées qu'une fois, et uniquement par la JVM, c'est une mauvaise idée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EQ_SELF_USE_OBJECT">
  <ShortDescription>Définition d'une méthode equals() covariante, Object.equals(Object) est hérité</ShortDescription>
  <LongDescription>{0} définit une méthode equals({0}) et utilise Object.equals(Object)</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une version covariante de la méthode <code>equals()</code>, mais appelle la méthode normale <code>equals(Object)</code> définie dans la classe de base <code>java.lang.Object</code>. La classe devrait probablement définir une version non covariante de <code>equals()</code>. (C'est-à-dire une méthode avec la signature <code>boolean equals(java.lang.Object)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EQ_SELF_NO_OBJECT">
  <ShortDescription>Définition d'une méthode equals() covariante</ShortDescription>
  <LongDescription>{0} définit la méthode equals({0}) mais pas equals(Object)</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une version covariante de <code>equals()</code>. Pour surcharger correctement la méthode <code>equals()</code> de <code>java.lang.Object</code>, le paramètre de <code>equals()</code> doit être du type <code>java.lang.Object</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_ARGUMENT_MIGHT_BE_NULL">
  <ShortDescription>Méthode ne testant pas les paramètres à null</ShortDescription>
  <LongDescription>{1} ne vérifie pas les paramètres à null</LongDescription>
  <Details>
<![CDATA[
<p>Un paramètre de cette méthode a été identifié comme une valeur pouvant être à <code>null</code>, mais qui est déréférencée sans test de nullité.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_EQUALS_SHOULD_HANDLE_NULL_ARGUMENT">
  <ShortDescription>Méthode equals() ne vérifiant pas la nullité</ShortDescription>
  <LongDescription>{1} ne vérifie pas la nullité d'un paramètre</LongDescription>
  <Details>
<![CDATA[
<p>Cette implémentation de <code>equals(Object)</code> ne respecte pas le contrat défini par <code>java.lang.Object.equals()</code> car elle ne vérifie la nullité du paramètre reçu en argument. Toutes les méthodes <code>equals()</code> doivent renvoyer <code>false</code> quand elles reçoivent une valeur à <code>null</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_DOES_NOT_HANDLE_NULL">
  <ShortDescription>Méthode equals() ne vérifiant pas le null</ShortDescription>
  <LongDescription>{1} ne vérifie le paramètre à null</LongDescription>
  <Details>
<![CDATA[
<p>Cette implémentation de <code>equals(Object)</code> contredit le contrat défini dans <code>java.lang.Object.equals()</code> car elle ne vérifie pas le cas du <code>null</code> passé en paramètre. Toutes les méthodes <code>equals()</code> devraient renvoyer <code>false</code> quand un <code>null</code> leur est passé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="CO_SELF_NO_OBJECT">
  <ShortDescription>Définition d'une méthode compareTo() covariante</ShortDescription>
  <LongDescription>{0} définit une méthode compareTo({0}) mais pas compareTo(Object)</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une version covariante de <code>compareTo()</code>. Pour correctement surcharger la méthode <code>compareTo() </code>de l'interface <code>Comparable</code>, le paramètre de <code>compareTo()</code> doit être du type <code>java.lang.Object</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="HE_HASHCODE_USE_OBJECT_EQUALS">
  <ShortDescription>La classe définit hashCode() et utilise Object.equals()</ShortDescription>
  <LongDescription>{0} définit hashCode() et utilise Object.equals()</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une méthode <code>hashCode()</code> mais hérite la méthode <code>equals()</code> de <code>java.lang.Object</code> (qui définit l'égalité par comparaison des références des objets). Bien que cela satisfasse certainement le contrat indiquant que les objets égaux doivent avoir des codes de hachage égaux, ce n'est certainement pas ce qui était voulu lors de la surcharge de la méthode <code>hashCode()</code> (Surcharger <code>hashCode()</code> implique que l'identité des objets soit basée sur des critères plus compliqués qu'une simple égalités des références.)</p>
<p>Si vous ne pensez pas que des instances de cette classe soient un jour insérées dans des <code>HashMap</code>/<code>HashTable</code>, l'implémentation recommendée de <code>hashCode</code> est :</p>
<p><pre>
public int hashCode() {
  assert false : "hashCode not designed";
  return 42; // any arbitrary constant will do 
  }
</pre></p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="HE_HASHCODE_NO_EQUALS">
  <ShortDescription>La classe définit hashCode() mais pas equals()</ShortDescription>
  <LongDescription>{0} définit hashCode() mais pas equals()</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une méthode <code>hashCode()</code> mais pas de méthode <code>equals()</code>. C'est pourquoi cette classe peut violer le contrat indiquant que des objets identiques doivent avoir des codes de hachage identiques.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="HE_EQUALS_USE_HASHCODE">
  <ShortDescription>La classe définit equals() et utilise Object.hashCode()</ShortDescription>
  <LongDescription>{0} définit equals() et utilise Object.hashCode()</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe surcharge <code>equals(Object)</code>, pas <code>hashCode()</code>, et hérite de l'implémentation de <code>hashCode()</code> issue de <code>java.lang.Object</code> (qui renvoie le code de hachage d'identité, une valeur arbitraire assignée à l'objet par la JVM). C'est pourquoi la classe a des chances de violer le contrat impliquant que des objets égaux doivent avoir des codes de hachage identiques.</p>
<p>Si vous ne pensez pas que des instances de cette classe soient un jour insérés dans des<code>HashMap</code>/<code>Hashtable</code>, l'implémentation recommendée est du type :</p>
<p><pre>
public int hashCode() {
  assert false : "hashCode not designed";
  return 42; // any arbitrary constant will do 
}
</pre></p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="HE_INHERITS_EQUALS_USE_HASHCODE">
  <ShortDescription>La classe hérite de equals() et utilise Object.hashCode()</ShortDescription>
  <LongDescription>{0} hérite de equals() et utilise de Object.hashCode()</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe hérite de la méthode <code>equals((Object)</code> d'une super-classe abstraite, et de la méthode <code>hashCode()</code> de l'objet <code>java.lang.Object</code> (qui renvoi le code de hachage d'identité, une valeur arbitraire assignée à l'objet par la JVM). C'est pourquoi la classe viole probablement le contrat indiquant que des objets égaux doivent avoir des codes de hachage identiques.</p>
<p>Si vous ne souhaitez pas définir une méthode <code>hashCode()</code> et/ou ne pensez pas que l'objet puisse un jour être mis dans des <code>HashMap</code>/<code>Hashtable</code>, définissez une méthode <code>hashCode()</code> déclenchant une <code>UnsupportedOperationException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="HE_EQUALS_NO_HASHCODE">
  <ShortDescription>La classe définit equals() mais pas hashCode()</ShortDescription>
  <LongDescription>{0} définit equals() mais pas hashCode()</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe surcharge <code>equals(Object)</code>, mais pas <code>hashCode()</code>. C'est pourquoi la classe peut violer le contrat indiquant que des objets égaux doivent avoir des codes de hachage identiques.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EQ_ABSTRACT_SELF">
  <ShortDescription>Une classe abstraite définit une méthode equals() covariante</ShortDescription>
  <LongDescription>La classe abstraite {0} définit une méthode equals({0})</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une version covariante de la méthode <code>equals()</code>. Pour surcharger correctement la méthode <code>equals()</code> de <code>java.lang.Object</code>, le paramètre de <code>equals()</code> doit être du type <code>java.lang.Object</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ES_COMPARING_STRINGS_WITH_EQ">
  <ShortDescription>Comparaison d'objets String utilisant == ou !=</ShortDescription>
  <LongDescription>Comparaison d'objets String utilisant == ou != dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code compare des objets <code>java.lang.String</code> au moyen de l'égalité par référence des opérateurs <code>==</code> ou <code>!=</code>. A moins que les deux chaînes ne soient des constantes dans le fichier source ou aient été internalisées au moyen de la méthode <code>String.intern()</code>, deux chaînes identiques peuvent être représentées par deux objets <code>String</code> différents. Envisagez d'utiliser la méthode <code>equals(Object)</code> à la place.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="CO_ABSTRACT_SELF">
  <ShortDescription>Une classe abstraite définit une méthode compareTo() covariante</ShortDescription>
  <LongDescription>La classe abstraite {0} définit une méthode compareTo({0})</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une version covariante de <code>compareTo()</code>. Pour surcharger correctement la méthode <code>compareTo()</code> de l'interface <code>Comparable</code>, le paramètre de <code>compareTo()</code> doit être du type <code>java.lang.Object</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IS_FIELD_NOT_GUARDED">
  <ShortDescription>Champ non protégé contre les accès concurrents</ShortDescription>
  <LongDescription>{1} n'est pas protégé contre les accès concurrents : il est verrouillé {2}% du temps</LongDescription>
  <Details>
<![CDATA[
<p>Ce champ est annoté avec <code>net.jcip.annotations.GuardedBy</code>, mais peut être utilisé d'une façon qui contredit l'annotation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IS2_INCONSISTENT_SYNC">
  <ShortDescription>Synchronisation incohérente</ShortDescription>
  <LongDescription>Synchronisation incohérente de {1}; verrouillée à {2}%</LongDescription>
  <Details>
<![CDATA[
<p>Les champs de cette classe semblent être accédés de façon incohérente vis-à-vis de la synchronisation. Le détecteur de bogue juge que :</p>
<ol>
  <li>la classe contient un mélange d'accès verrouillés et non verrouillés,</li>
  <li>au moins un des accès verrouillés est effectué par une des propres méthodes de la classe,</li>
  <li>le nombre d'accès (lectures et écritures) non synchronisés ne représente pas plus d'un tiers de tous les accès, avec plus de deux fois plus d'écritures que de lectures.</li>
</ol>
<p>Un bogue typique déclenchant ce détecteur est l'oubli de la synchronisation sur l'une des méthodes d'une classe qui essaye d'être sûre vis-à-vis des threads.</p>
<p>Vous pouvez sélectionner les noeuds nommés "Accès non synchronisés" pour avoir la position exacte dans le code où le détecteur pense qu'un champ est accédé sans synchronisation.</p>
<p>Notez qu'il y a diverses sources d'inexactitude dans ce détecteur ; par exemple, le détecteur ne peut pas repérer statiquement toutes les situations dans lesquelles un verrou est obtenu. En fait, même lorsque le détecteur repère effectivement des accès avec et sans verrou, le code concerné peut quand même être correct.</p>
<p>Cette description se réfère à la version "IS2" du détecteur, qui est plus précise pour détecter les accès avec et sans verrous que l'ancien détecteur "IS".</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NN_NAKED_NOTIFY">
  <ShortDescription>Appel notify() isolé dans une méthode</ShortDescription>
  <LongDescription>Présence d'un notify() isolé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Un appel à <code>notify()</code> ou <code>notifyAll()</code> est effectué sans aucun changement (apparent) de l'état d'un objet modifiable. En général, appeler une méthode <code>notify()</code> dans un moniteur est effectué parce qu'une condition quelconque attendue par un autre thread est devenue vraie. Dans tous les cas, pour que la condition ait un sens, elle doit porter sur un objet visible des deux threads.</p>
<p>Ce bogue n'indique pas nécessairement une erreur puisque la modification de l'état de l'objet peut avoir eu lieu dans une méthode qui appelle la méthode contenant la notification.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_EXPOSE_REP">
  <ShortDescription>Une méthode statique publique risque d'exposer une représentation interne en renvoyant un tableau</ShortDescription>
  <LongDescription>La méthode statique publique {1} peut exposer une représentation interne en renvoyant {2}</LongDescription>
  <Details>
<![CDATA[
<p>Une méthode statique publique renvoit une référence à un tableau faisant partie de l'état statique de la classe. Tout code appelant cette méthode peut librement modifier le tableau sous-jacent. Une correction possible serait de renvoyer une copie du tableau.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EI_EXPOSE_REP">
  <ShortDescription>Une méthode peut exposer sa représentation interne en renvoyant une référence à un objet modifiable</ShortDescription>
  <LongDescription>La méthode {1} risque d'exposer sa représentation interne en renvoyant {2}</LongDescription>
  <Details>
<![CDATA[
<p>Renvoyer une référence à un objet modifiable stocké dans les champs d'un objet expose la représentation interne de l'objet. Si des instances sont accédées par du code non fiable, et que des modifications non vérifiées peuvent compromettre la sécurité ou d'autres propriétés importantes, vous devez faire autre chose. Renvoyer une nouvelle copie de l'objet est une meilleur approche dans de nombreuses situations.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EI_EXPOSE_REP2">
  <ShortDescription>Une méthode expose sa représentation interne en incorporant une référence à un objet modifiable</ShortDescription>
  <LongDescription>La méthode {1} risque d'exposer sa représentation interne en stockant un objet externe modifiable dans {2}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code stocke une référence à un objet externe modifiable dans la représentation interne de l'objet. Si des instances sont accédées par du code non fiable, et que des modifications non vérifiées peuvent compromettre la sécurité ou d'autres propriétés importantes, vous devez faire autre chose. Stocker une copie de l'objet est une meilleur approche dans de nombreuses situations.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EI_EXPOSE_STATIC_REP2">
  <ShortDescription>Une méthode peut exposer un état interne statique en stockant un objet modifiable dans un champs statique</ShortDescription>
  <LongDescription>La méthode {1} peut exposer un état interne statique en stockant un objet modifiable dans le champs statique {2}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code stocke une référence à un objet modifiable externe dans un champs statique. Si des modifications non vérifiées de l'objet modifiable peuvent compromettre la sécurité ou d'autres propriétés importantes, vous devez faire autre chose. Stocker une copie de l'objet est souvent une meilleur approche.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RU_INVOKE_RUN">
  <ShortDescription>Invocation de run() sur un thread (Vouliez-vous plutôt dire start() ?)</ShortDescription>
  <LongDescription>{1} appelle explicitement run() sur un thread (Vouliez-vous plutôt dire start() ?)</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle explicitement <code>run()</code> sur un objet. En général, les classes implémentent l'interface <code>Runnable</code> parce qu'elles vont avoir leur méthode <code>run()</code> invoquée dans un nouveau thread, auquel cas <code>Thread.start()</code> est la bonne méthode à appeler.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SP_SPIN_ON_FIELD">
  <ShortDescription>Méthode bouclant sur un champ</ShortDescription>
  <LongDescription>Boucle sur {3} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode tourne en rond sur une boucle qui lit un champ. Le compilateur est autorisé à sortir la lecture de la boucle, créant ainsi une boucle infinie. La classe devrait être modifiée afin d'être correctement synchronisée (avec des appels à <code>wait()</code> et <code>notify()</code>).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NS_NON_SHORT_CIRCUIT">
  <ShortDescription>Utilisation discutable de logique binaire</ShortDescription>
  <LongDescription>Utilisation discutable de logique binaire dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code semble utiliser de la logique binaire (Ex. : <code>&amp;</code> ou <code>|</code>) plutôt que les opérateurs booléens (<code>&amp;&amp;</code> ou <code>||</code>). La logique binaire entraîne l'évaluation systématique de toute l'expression, même quand le résultat pourrait être immédiatement déduit. Ceci est moins performant et peut provoquer des erreurs lorsque la partie gauche de l'expression masque des cas de la partie droite.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="TLW_TWO_LOCK_WAIT">
  <ShortDescription>wait() avec deux verrous en attente</ShortDescription>
  <LongDescription>La méthode wait() a deux verrous en attente dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Attendre sur on moniteur alors que deux verrous sont détenus peut entraîner un blocage fatal (deadlock). Exécuter un <code>wait()</code> ne libère que le verrou sur l'objet accueillant le <code>wait()</code>, mais aucun autre verrou. Ce n'est pas obligatoirement un bogue, mais il vaut mieux examiner ça en détails.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="TLW_TWO_LOCK_NOTIFY" deprecated="true">
  <ShortDescription>Notify avec deux verrous en cours</ShortDescription>
  <LongDescription>notify() ou notifyAll*() avec deux verrous en cours dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code appelle <code>notify()</code> ou <code>notifyAll()</code> alors que deux verrous sans en cours. Si cette notification tente de réveiller un <code>wait()</code> basé sur les mêmes verrous cela peut provoquer un inter-blocage puisque le <code>wait()</code> ne libérera qu'un des verrous et que le <code>notify()</code> ne pourra pas récupérer l'autre verrou et échouera. Si il y a aussi une alarme sur un <code>wait()</code> avec deux verrous, la probabilité d'une erreur est plutôt élevée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UW_UNCOND_WAIT">
  <ShortDescription>Méthode contenant un wait() non conditionné</ShortDescription>
  <LongDescription>La méthode {1} contient un wait() non conditionné</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un appel à <code>java.lang.Object.wait()</code> qui n'est pas protégé par une condition. Si la condition que la méthode essaye d'attendre a déjà été remplie, le thread risque d'attendre indéfiniment.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UR_UNINIT_READ">
  <ShortDescription>Lecture d'un champ non initialisé dans un constructeur</ShortDescription>
  <LongDescription>Lecture du champ {2} non initialisé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce constructeur lit un champ qui n'a pas encore été initialisé. Une des causes les plus fréquentes est l'utilisation accidentelle par le développeur du champ au lieu d'un des paramètres du constructeur.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UG_SYNC_SET_UNSYNC_GET">
  <ShortDescription>Méthode getXXX non synchronisée, méthode setXXX synchronisée</ShortDescription>
  <LongDescription>{1} n'est pas synchronisée alors que {2} l'est</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe contient des méthodes <code>getXXX</code> et <code>setXXX</code> similaires dont la méthode <code>setXXX</code> est synchronisée tandis que la méthode <code>getXXX</code> ne l'est pas. Ceci peut entraîner un comportement incorrect à l'exécution car l'appelant de la méthode <code>getXXX</code> ne verra pas obligatoirement l'objet dans un état consistant. La méthode <code>getXXX</code> devrait être synchronisée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IC_INIT_CIRCULARITY">
  <ShortDescription>Initialisation circulaire</ShortDescription>
  <LongDescription>Initialisation circulaire entre {0} et {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une initialisation circulaire a été détectée dans les initialisations de variables statiques de deux classes référencées par l'instance en erreur. De nombreuses sortes de comportements inattendus peuvent surgir d'une telle situation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IC_SUPERCLASS_USES_SUBCLASS_DURING_INITIALIZATION">
  <ShortDescription>Classe mère utilisant une sous-classe durant son initialisation</ShortDescription>
  <LongDescription>L'initialisation de {0} accède à la classe {2}, qui n'est pas encore initialisée</LongDescription>
  <Details>
<![CDATA[
<p>Durant l'intialisation, une classe utilise activement l'une de ses sous-classes. Cette sous-classe ne sera pas encore initialisée lors de la première utilisation. Par exemple, dans le code suivant, <code>foo</code> sera à <code>null</code>.</p>
<p><code><pre>
public class CircularClassInitialization {
    static class InnerClassSingleton extends CircularClassInitialization {
        static InnerClassSingleton singleton = new InnerClassSingleton();
    }
    static CircularClassInitialization foo = InnerClassSingleton.singleton;
}
</pre></code></p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IT_NO_SUCH_ELEMENT">
  <ShortDescription>La méthode next() de Iterator ne peut pas déclencher une exception NoSuchElement</ShortDescription>
  <LongDescription>{1} ne peut pas déclencher l'exception NoSuchElement</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe implémente l'interface <code>java.util.Iterator</code>. Néanmoins, sa méthode <code>next()</code> n'est pas capable de déclencher <code>java.util.NoSuchElementException</code>. La méthode <code>next()</code> devrait être modifiée pour déclencher <code>NoSuchElementException</code> si elle est appelée alors qu'il n'y a plus d'éléments à renvoyer.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ESync_EMPTY_SYNC">
  <ShortDescription>Bloc synchronisé vide</ShortDescription>
  <LongDescription>Bloc synchronisé vide dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Présence d'un bloc synchronisé vide:</p>
<pre>
synchronized() {}
</pre>
<p>L'utilisation de blocs synchronisés vides est bien plus subtile et dure à réaliser correctement que bien des gens ne le reconnaissent, et de plus ne correspond que rarement à la meilleure des solutions.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IS_INCONSISTENT_SYNC">
  <ShortDescription>Synchronisation incohérente</ShortDescription>
  <LongDescription>Synchronisation incohérente de {1}; verrouillée à {2}%</LongDescription>
  <Details>
<![CDATA[
<p>Les champs de cette classe semblent être accédés de façon incohérente vis-à-vis de la synchronisation. Le détecteur indique que :</p>
<ol>
  <li>la classe mélange les accès verrouillés et non verrouillés,</li>
  <li>au moins des accès verrouillés est effectué par l'une des propres méthodes de la classe,</li>
  <li>le nombre d'accès non synchronisés à un champ (lectures et écritures) ne dépasse pas un tiers de l'ensemble des accès, les écritures étant deux fois plus présentes que les lectures.</li>
</ol>
  <p>Typiquement, oublier de synchroniser une des méthodes dans une classe essayant d'être sûre vis-à-vis des threads est un bogue signalé par ce détecteur.</p>
<p>NB : il y a diverses sources d'inexactitude dans ce détecteur ; par exemple, le détecteur ne peut pas déterminer statiquement toutes les situations dans lesquelles un verrou est détenu. Ainsi, même lorsque le détecteur repère effectivement des accès verrouillés / non verrouillés, le code en question peut tout de même être correct.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ML_SYNC_ON_UPDATED_FIELD">
  <ShortDescription>La méthode se synchronise sur un champ mis à jour</ShortDescription>
  <LongDescription>La méthode {1} se synchronise sur le champ mis à jour {2}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode se synchronise sur le champ modifiable d'une référence objet. Il y a peu de chances que cela ait un sens puisque les différents threads se synchroniserons par rapport à différents objets.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_OOI_PKGPROTECT">
  <ShortDescription>Le champ devrait être sorti de l'interface et mis en package protected</ShortDescription>
  <LongDescription>{1} devrait être sorti de l'interface et mis en package protected</LongDescription>
  <Details>
<![CDATA[
<p>Un champ final static défini dans une interface référence un objet modifiable tel qu'un tableau ou une table de hachage. Cet objet pourrait être modifié par accident ou par du code sournois d'un autre paquetage. Pour résoudre cela et éviter cette vulnérabilité, le champ doit être intégré dans une classe et sa visibilité modifiée en package protected.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_FINAL_PKGPROTECT">
  <ShortDescription>Le champ devrait être à la fois final et package protected</ShortDescription>
  <LongDescription>{1} devrait être à la fois final et package protected</LongDescription>
  <Details>
<![CDATA[
<p>Un champ statique modifiable peut-être changé par accident ou par du code malveillant d'un autre paquetage. Le champ devrait être package protected et/ou final pour éviter cette vulnérabilité.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_SHOULD_BE_FINAL">
  <ShortDescription>Un champ n'est pas final alors qu'il devrait l'être</ShortDescription>
  <LongDescription>{1} n'est pas final mais devrait l'être</LongDescription>
  <Details>
<![CDATA[
<p>Un champ statique modifiable peut-être changé par accident ou par du code malveillant d'un autre paquetage. Le champ devrait être final pour éviter cette vulnérabilité.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_PKGPROTECT">
  <ShortDescription>Un champ devrait être package protected</ShortDescription>
  <LongDescription>{1} devrait être package protected</LongDescription>
  <Details>
<![CDATA[
<p>Un champ statique modifiable peut-être changé par accident ou par du code malveillant d'un autre paquetage. Le champ devrait être package protected pour éviter cette vulnérabilité.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_MUTABLE_HASHTABLE">
  <ShortDescription>Un champ modifiable est une Hashtable</ShortDescription>
  <LongDescription>{1} une Hashtable modifiable</LongDescription>
  <Details>
<![CDATA[
<p>Le champ est une référence final static à une <code>Hashtable</code> et peut-être modifié par accident ou par du code malveillant d'un autre paquetage. Ce code peut librement modifier le contenu de la <code>Hashtable</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_MUTABLE_ARRAY">
  <ShortDescription>Un champ est un tableau modifiable</ShortDescription>
  <LongDescription>{1} est un tableau modifiable</LongDescription>
  <Details>
<![CDATA[
<p>Le champ est une référence final static à un tableau et peut-être modifié par accident ou par du code malveillant d'un autre paquetage. Ce code peut librement modifier le contenu du tableau.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MS_CANNOT_BE_FINAL">
  <ShortDescription>Un champ n'est pas final et ne peut pas être protégé face à du code malveillant</ShortDescription>
  <LongDescription>{1} n'est pas final et n'est pas protégé face à du code malveillant</LongDescription>
  <Details>
<![CDATA[
<p>Un champ statique modifiable peut-être modifié par accident ou par du code malveillant. Malheureusement, la façon dont ce champ est utilisé ne permet une correction aisée de ce problème.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IA_AMBIGUOUS_INVOCATION_OF_INHERITED_OR_OUTER_METHOD">
  <ShortDescription>Appel ambigu d'une méthode hérité ou externe</ShortDescription>
  <LongDescription>Appel ambigu de la méthode héritée ou externe {2} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une classe interne invoque une méthode qui peut être résolue comme une méthode héritée ou comme une méthode définie dans une classe externe. La sémantique de Java fait qu'elle sera résolue en invoquant la méthode héritée, mais ce n'est peut être pas votre intention. Si vous souhaitez réellement invoquer la méthode héritée, faite le en utilisant <code>super</code> (Ex : appelé <code>super.foo(17)</code>) ce qui clarifiera votre code pour les autres lecteurs et pour FindBugs.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_CLASS_NAMING_CONVENTION">
  <ShortDescription>Nom de classe devant commencer par une majuscule</ShortDescription>
  <LongDescription>Le nom de la classe {0} ne commence pas par une majusucle</LongDescription>
  <Details>
<![CDATA[
<p>Les noms de classe doivent être en minuscules avec la première lettre de chaque mot en majuscules. Essayez de conserver vos noms de classes simples et explicites. Utilisez des mots entiers et évitez acronymes et abbréviations (à moins que l'abbréviation soit plus largement utilisée que la forme longue, comme "URL" ou "HTML").</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_METHOD_NAMING_CONVENTION">
  <ShortDescription>Nom de méthode devant commencer par une minuscule</ShortDescription>
  <LongDescription>Le nom de la méthode {1} ne commence pas par une minuscule</LongDescription>
  <Details>
<![CDATA[
<p>Les noms de méthodes devraient être des verbes en minuscules, avec la première lettre des mots, après le premier, en majuscules.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_FIELD_NAMING_CONVENTION">
  <ShortDescription>Nom de champ devant commencer par une minuscule</ShortDescription>
  <LongDescription>Le nom du champ {1} ne commence pas par une minuscule</LongDescription>
  <Details>
<![CDATA[
<p>Les noms de champs qui ne sont pas finaux devraient être en minuscules avec la première lettre des mots, après le premier, en majuscule.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_VERY_CONFUSING">
  <ShortDescription>Noms de méthodes très ambigus</ShortDescription>
  <LongDescription>Il est très ambigu d'avoir des méthodes {1} et {3}</LongDescription>
  <Details>
<![CDATA[
<p>Les méthodes indiquées ont des noms qui ne diffèrent que par les majuscules. C'est d'autant plus ambigu que les classes comportant ces méthodes sont liées par héritage.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_CONFUSING">
  <ShortDescription>Noms de méthodes ambigus</ShortDescription>
  <LongDescription>Il est ambigu d'avoir des méthodes {1} et {3}</LongDescription>
  <Details>
<![CDATA[
<p>Les méthodes indiquées ont des noms qui ne diffèrent que par les majuscules.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_METHOD_CONSTRUCTOR_CONFUSION">
  <ShortDescription>Confusion apparente entre une méthode et un constructeur</ShortDescription>
  <LongDescription>La méthode {1} était probablement destinée à être un constructeur</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode a le même nom que la classe dans laquelle elle est déclarée. Il est probable qu'elle devait être un constructeur.
Si c'est bien le cas, retirez la déclaration d'une valeur de retour.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_LCASE_HASHCODE">
  <ShortDescription>La classe définit hashcode() ; ne devrait-ce pas être hashCode() ?</ShortDescription>
  <LongDescription>La classe {0} définit hashcode() ; ne devrait-ce pas être hashCode() ?</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une méthode nommée <code>hashcode()</code>. Cette méthode ne surcharge pas la méthode <code>hashCode()</code> de <code>java.lang.Object</code>, surchage qui était pourtant sans doute le but visé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_LCASE_TOSTRING">
  <ShortDescription>La classe définit tostring() ; ne devrait-ce pas être toString() ?</ShortDescription>
  <LongDescription>La classe {0} définit tostring() ; ne devrait-ce pas être toString() ?</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une méthode appelée <code>tostring()</code>. Cette méthode ne surcharge pas la méthode <code>toString()</code> de <code>java.lang.Object</code>, surchage qui était pourtant sans doute le but visé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_BAD_EQUAL">
  <ShortDescription>La classe définit equal() ; ne devrait-ce pas être equals() ?</ShortDescription>
  <LongDescription>La classe {0} définit equal() ; ne devrait-ce pas être equals() ?</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit une méthode <code>equal(Object)</code>. Cette méthode ne surcharge pas la méthode <code>equals(Object)</code> de <code>java.lang.Object</code>, surchage qui était pourtant sans doute le but visé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NM_CLASS_NOT_EXCEPTION">
  <ShortDescription>Cette classe ne dérive pas d'Exception, même si son nom le sous-entend</ShortDescription>
  <LongDescription>La classe {0} ne dérive pas d'Exception, alors que son nom le sous-entend</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe n'est pas dérivée d'une autre <code>Exception</code> alors que son nom se termine par 'Exception'. Ceci risque de porter à confusion les utilisateurs de cette classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RR_NOT_CHECKED">
  <ShortDescription>La méthode ignore le résultat de InputStream.read()</ShortDescription>
  <LongDescription>{1} ignore le résultat de {2}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode ignore le code retour d'une des variantes de <code>java.io.InputStream.read()</code> qui peut renvoyer de multiples octets. Si la valeur renvoyée n'est pas vérifiée, l'appelant ne sera pas capable de gérer correctement le cas ou moins d'octets que prévu auront été lus. C'est un bogue particulièrement insidieux car dans la plupart des programmes les lectures renvoient effectivement souvent le nombre d'octets demandé, les plantages restant sporadiques.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SR_NOT_CHECKED">
  <ShortDescription>La méthode ignore le résultat de InputStream.skip()</ShortDescription>
  <LongDescription>{1} ignore le résultat de {2}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode ignore la valeur renvoyée par <code>java.io.InputStream.skip()</code>, qui peut sauter de multiples octets. Si la valeur renvoyée n'est pas vérifiée, l'appelant n'est pas capable de gérer correctement les cas ou moins d'octets que prévu auront été sautés. C'est un type de bogue particulièrement insidieux car la plupart du temps le bon nombre d'octet sera effectivement sauté, et les plantages seront sporadiques. Néanmoins, sur les flux bufferisés, <code>skip()</code> ne s'applique qu'aux données du buffer et échoue fréquemment à sauter le nombre d'octets demandé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_READ_RESOLVE_MUST_RETURN_OBJECT">
  <ShortDescription>La méthode readResolve doit retourner un Object</ShortDescription>
  <LongDescription>La méthode {1} doit être déclarée avec un type de retour Object plutôt que {1.returnType}</LongDescription>
  <Details>
<![CDATA[
<p>Pour que la méthode <code>readResolve</code> soit prise en compte pas le mécanisme de sérialisation, elle doit avoir Object comme type de retour.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_TRANSIENT_FIELD_NOT_RESTORED">
  <ShortDescription>Champ "transient" non positionné lors de la désérialisation</ShortDescription>
  <LongDescription>Le champ {1} est transient mais n'est pas alimenté lors de la désérialisation</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe contient un champ qui est mis-à-jour à de nombreux endrois dans la classe, et qui semble faire parti du démarrage de la classe. Mais, ce champ étant marqué comme <code>transient</code> et n'étant pas alimenté par les méthodes <code>readObject</code> et <code>readResolve</code>, il contiendra la valeur par défaut dans toutes les instances désérialisées de la classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_METHOD_MUST_BE_PRIVATE">
  <ShortDescription>Méthode devant être privée pour que la sérialisation fonctionne</ShortDescription>
  <LongDescription>La méthode {1.givenClass} doit être privée pour être invoquée lors de la sérialisation/désérialisation de {0}</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe implémente l'interface <code>Serializable</code> et défini une méthode pour personnaliser la sérialisation/désérialisation. Mais cette méthode n'étant pas déclarée privée elle sera ignorée silencieusement par les API de sérialisation/désérialisation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_NO_SUITABLE_CONSTRUCTOR_FOR_EXTERNALIZATION">
  <ShortDescription>La classe est Externalizable mais ne définit pas de constructeur par défaut</ShortDescription>
  <LongDescription>{0} est Externalizable mais ne définit pas de constructeur par défaut</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe implémente l'interface <code>Externalizable</code>, mais ne définit pas de constructeur par défaut. Quand les objets <code>Externalizable</code> sont déserialisés, ils doivent d'abord être construit au moyen du constructeur par défaut. Cette classe n'en ayant pas, sérialisation et désérialisation échoueront à l'exécution.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_NO_SUITABLE_CONSTRUCTOR">
  <ShortDescription>La classe est Serializable mais sa super-classe ne possède pas de constructeur par défaut visible</ShortDescription>
  <LongDescription>{0} est Serializable mais sa super-classe ne possède pas de constructeur par défaut visible</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe implémente l'interface <code>Serializable</code> mais pas sa super-classe. Quand un tel objet est désérialisé, les champs de la classe mère doivent être initialisés en invoquant le constructeur par défaut de la super-classe. Comme la super-classe n'en a pas, sérialisation et désérialisation échoueront à l'exécution.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_NO_SERIALVERSIONID">
  <ShortDescription>La classe est Serializable, mais ne définit pas serialVersionUID</ShortDescription>
  <LongDescription>{0} est Serializable ; pensez à déclarer serialVersionUID</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe implémente l'interface <code>Serializable</code> mais ne définit pas de champ <code>serialVersionUID</code>. Une modification aussi simple qu'ajouter une référence vers un objet <code>.class</code> ajoutera des champs synthétiques à la classe, ce qui malheureusement changera la valeur implicite de <code>serialVersionUID</code> (Ex. : ajouter une référence à <code>String.class</code> générera un champ statique <code>class$java$lang$String</code>). De plus, différents compilateurs source vers bytecode peuvent utiliser différentes conventions de nommage pour les variables synthétiques générées pour référencer les objets classes et les classes internes. Afin de garantir l'interopérabilité de <code>Serializable</code> suivant les versions, pensez à ajouter un champ <code>serialVersionUID</code> explicite.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_COMPARATOR_SHOULD_BE_SERIALIZABLE">
  <ShortDescription>Comparateur n'implémentant pas Serializable</ShortDescription>
  <LongDescription>{0} implémente Comparator mais pas Serializable</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe implémente l'interface <code>Comparator</code>. Vous devriez vérifier si elle doit ou pas également implémenter l'interface <code>Serializable</code>. Si un comparateur est utilisé pour construire une collection triée, telle que <code>TreeMap</code>, alors le <code>TreeMap</code> ne sera sérialisable uniquement si le compareteur l'est aussi. Puisque la plupart des comparateurs ont de petits voire aucun états, les rendre sérialisables est généralement une technique de programmation défensive simple et bénéfique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SF_SWITCH_FALLTHROUGH">
  <ShortDescription>Un switch comporte un cas qui déborde sur le suivant</ShortDescription>
  <LongDescription>Un switch de {1} comporte un cas qui déborde sur le suivant</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un <code>switch</code> dont l'un des cas déborde sur le suivant. Normalement, vous devez terminer chaque cas avec une instruction <code>break</code> ou <code>return</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="WS_WRITEOBJECT_SYNC">
  <ShortDescription>Seule la méthode writeObject() est synchronisée</ShortDescription>
  <LongDescription>Seule la méthode writeObject() de {0} est synchronisée</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe a une méthode <code>writeObject()</code> qui est synchronisée ; mais aucune autre méthode de cette classe n'est synchronisée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RS_READOBJECT_SYNC">
  <ShortDescription>Seule la méthode readObject() est synchronisée</ShortDescription>
  <LongDescription>Seule la méthode readObject() de {0} est synchronisée</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe <code>Serializable</code> définit une méthode <code>readObject()</code> qui est synchronisée. Par définition, un objet créé par désérialisation n'est accessible que par un unique thread, donc il n'y a aucun intérêt à synchroniser <code>readObject()</code>. Si la méthode <code>readObject()</code> en elle-même rend l'objet visible d'un autre thread, vous avez un exemple de style de code très douteux.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_NONSTATIC_SERIALVERSIONID">
  <ShortDescription>serialVersionUID n'est pas static</ShortDescription>
  <LongDescription>{1} n'est pas static</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit un champ <code>serialVersionUID</code> qui n'est pas statique. Le champ devrait être rendu statique si son but est de préciser l'identifiant de version utilisé pour la sérialisation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_NONFINAL_SERIALVERSIONID">
  <ShortDescription>serialVersionUID n'est pas final</ShortDescription>
  <LongDescription>{1} n'est pas final</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit un champ <code>serialVersionUID</code> qui n'est pas <code>final</code>. Ce champ devrait être rendu <code>final</code> si son but est de préciser l'identifiant de version utilisé pour la sérialisation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_NONLONG_SERIALVERSIONID">
  <ShortDescription>serialVersionUID n'est pas de type long</ShortDescription>
  <LongDescription>{1} n'est pas long</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit un champ <code>serialVersionUID</code> qui n'est pas de type <code>long</code>. Ce champ devrait être de type <code>long</code> si son but est de préciser l'identifiant de version utilisé pour la sérialisation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_BAD_FIELD">
  <ShortDescription>Champ d'instance non transient et non sérialisable dans une classe sérialisable</ShortDescription>
  <LongDescription>La classe {0} définit le champ d'instance {1} non transient et non sérialisable</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe <code>Serializable</code> définit un champ d'instance non primitif qui n'est ni <code>transient</code>, ni <code>Serializable</code> ou <code>java.lang.Object</code>, et qui ne semble pas implémenter l'interface <code>Externalizable</code> ou les méthodes <code>readObject()</code> et <code>writeObject()</code>. Les objets de cette classe ne seront pas désérialisés correctement si un objet non <code>Serializable</code> est stocké dans ce champ.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SE_BAD_FIELD_STORE">
  <ShortDescription>Valeur non sérialisable stockée dans un champ d'instance de classe sérialisable</ShortDescription>
  <LongDescription>{2} est stocké dans le champ non transient {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur non sérialisable est stockée dans un champ non <code>transient</code> d'une classe sérialisable.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SC_START_IN_CTOR">
  <ShortDescription>Un constructeur invoque Thread.start()</ShortDescription>
  <LongDescription>{1} invoque {2}</LongDescription>
  <Details>
<![CDATA[
<p>Le constructeur lance un thread. Il y a de fortes chances que ce soit une erreur si cette classe est un jour dérivée ou étendue puisque que le thread sera alors lancé avant que le constructeur de la classe dérivée ne soit appelé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SS_SHOULD_BE_STATIC">
  <ShortDescription>Champ non lu : devrait-il être statique ?</ShortDescription>
  <LongDescription>Champ non lu : {1} devrait-il être statique ?</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe contient un champ d'instance <code>final</code> qui est initialisé par une valeur statique déterminée à la compilation. Envisagez de rendre ce champ <code>static</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UUF_UNUSED_FIELD">
  <ShortDescription>Champ inutilisé</ShortDescription>
  <LongDescription>Champ inutilisé : {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce champ n'est jamais utilisé. Envisagez de le supprimer de la classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="URF_UNREAD_FIELD">
  <ShortDescription>Champ inutilisé</ShortDescription>
  <LongDescription>Champ inutilisé : {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce champ n'est jamais lu. Envisagez de le supprimer de la classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="QF_QUESTIONABLE_FOR_LOOP">
  <ShortDescription>Incrémentation compliquée, subtile au incorrecte dans une boucle for</ShortDescription>
  <LongDescription>Incrémentation compliquée, subtile au incorrecte dans la boucle for {1}</LongDescription>
  <Details>
<![CDATA[
<p>Etes vous certain que cette boucle incrémente la variable voulue ? Il sembleraît qu'une autre variable est initialisée et vérifiée par la boucle.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UWF_NULL_FIELD">
  <ShortDescription>Champ uniquement mis à null</ShortDescription>
  <LongDescription>Le champ {1} est uniquement mis à null</LongDescription>
  <Details>
<![CDATA[
<p>Ce champ est uniquement alimenté par la constante <code>null</code> et donc toutes les lectures de ce champ renverront <code>null</code>. Vérifiez si c'est une erreur ou alors supprimez ce champ qui est inutile.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UWF_UNWRITTEN_FIELD">
  <ShortDescription>Champ jamais écrit</ShortDescription>
  <LongDescription>Champ jamais écrit : {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce champ n'est jamais alimenté. Toutes les lectures vont renvoyer sa valeur par défaut. Recherchez les erreurs (devrait-il avoir été initialisé ?) ou supprimez le s'il est inutile.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD">
  <ShortDescription>Ecriture d'un champ statique depuis la méthode d'une instance</ShortDescription>
  <LongDescription>Ecriture d'un champ statique {2} depuis la méthode d'une instance {1}</LongDescription>
  <Details>
<![CDATA[
<p>La méthode de l'instance écrit la valeur d'un champ statique. Cela peut être difficile à gérer si plusieurs instances ont la possibilité d'écrire cette valeur et cela ressemble surtout à une mauvaise pratique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_LOAD_OF_KNOWN_NULL_VALUE">
  <ShortDescription>Chargement d'une valeur connue pour être à null</ShortDescription>
  <LongDescription>Chargement d'une valeur connue pour être à null dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>La variable référencée est connue pour être à <code>null</code> suite à une vérification précédente. Bien que cela soit valide, ce peut être une erreur (peut-être vouliez-vous référencer une autre valeur ou le test précédent aurait-il due vérifier non-null plutôt que null).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_IMMEDIATE_DEREFERENCE_OF_READLINE">
  <ShortDescription>Déréférencement immédiat du résultat d'un readLine()</ShortDescription>
  <LongDescription>Déréférencement immédiat du résultat d'un readLine() dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le résultat d'un appel à <code>readLine()</code> est immédiatement déréférencé. S'il n'y a plus d'autre lignes de texte à lire, <code>readLine()</code> retournera <code>null</code> ce qui provoquera une <code>NullPointerException</code> lors du déréférencement.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_UNWRITTEN_FIELD">
  <ShortDescription>Lecture d'un champ jamais écrit</ShortDescription>
  <LongDescription>Lecture d'un champ jamais alimenté dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le programme déréférence un champ qui ne semble jamais alimenté par une valeur non nulle. Déréférencer cette valeur provoquera une <code>NullPointerException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SIC_INNER_SHOULD_BE_STATIC">
  <ShortDescription>Devrait être une classe interne statique</ShortDescription>
  <LongDescription>La classe {0} devrait-elle être une classe interne static ?</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe est une classe interne, mais n'utilise pas sa référence vers l'objet qui l'a créée. Cette référence rend les instances de cette classe plus grosses et peut garder active la référence à l'objet créateur plus longtemps que nécessaire. Si possible, la classe devrait être transformée en classe interne <code>static</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR" deprecated="true">
  <ShortDescription>Lecture d'un champ non initalisé dans le constructeur</ShortDescription>
  <LongDescription>Lecture d'un champ non initalisé dans le constructeur {1}</LongDescription>
  <Details>
<![CDATA[
<p>Lecture d'un champ qui n'est jamais initialisé dans aucun constructeur, et qui sera <code>null</code> une fois l'initialisation de l'objet terminée. Ce peut être un erreur de code, ou bien la classe contenant le champ est construite de telle manière que le champ est écrit en fonction de l'appel de méthodes dans un certain ordre (un peu délicat mais pas nécessairement mauvais).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR">
  <ShortDescription>Champ non initialisé dans le constructeur</ShortDescription>
  <LongDescription>Le champ n'est pas initialisé dans le constructeur {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce champ n'est jamais initialisé dans aucun constructeur, et est de ce fait <code>null</code> une fois l'objet initialisé. Soit il s'agit d'une erreur, soit il s'agit d'un design douteux puisque ce champ génèra une exception s'il est déréférencé avant toute initialisation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SIC_INNER_SHOULD_BE_STATIC_ANON">
  <ShortDescription>Peut-être transformée en classe interne statique nommée</ShortDescription>
  <LongDescription>La classe {0} pourrait-être transformée en classe interne static</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe est une classe interne qui n'utilise pas sa référence vers l'objet qui l'a créée. Cette référence rend l'objet plus gros et peut garder active la référence de l'objet créateur plus longtemps que nécessaire. Si possible, la classe devrait être transformée en classe interne <code>static</code>. Puisque les classes anonymes ne peuvent pas être marquées comme <code>static</code>, il faudrait également nommer cette classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SIC_INNER_SHOULD_BE_STATIC_NEEDS_THIS">
  <ShortDescription>Pourrait-être transformée en classe interne statique</ShortDescription>
  <LongDescription>La classe {0} pourrait-être transformée en classe interne statique</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe est une classe interne mais elle n'utilise pas sa référence vers l'objet qui l'a créée, à part durant la création de l'objet interne. Cette référence rend les instances de cette classe plus grosses et peut forcer à garder active la référence de l'objet créateur plus longtemps que nécessaire. Si possible, la classe devrait-être transformée en classe interne <code>static</code>. Puisque la référence à l'objet créateur est requise durant la construction de la classe interne, le constructeur de celle-ci devrait-être modifié afin d'accepter en argument cette référence.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="WA_NOT_IN_LOOP">
  <ShortDescription>Méthode contenant un wait() en dehors d'une boucle</ShortDescription>
  <LongDescription>wait() en dehors d'une boucle dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un appel à <code>java.lang.Object.wait()</code> qui n'est pas dans une boucle. Si le moniteur est utilisé pour des conditions multiples, la condition que l'appelant attend peut ne pas être celle qui s'est réellement déclenchée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="WA_AWAIT_NOT_IN_LOOP">
  <ShortDescription>Condition.await() en dehors d'une boucle</ShortDescription>
  <LongDescription>Condition.await() en dehors d'une boucle dans la méthode {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un appel à <code>java.util.concurrent.await()</code> (ou une variante) qui n'est pas dans une boucle. Si cet objet est utilisé pour de multiples conditions, la condition que l'appelant espère réveiller pourra être ou ne pas être celle qui le sera effectivement.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NO_NOTIFY_NOT_NOTIFYALL">
  <ShortDescription>Utilisation de notify() plutôt que notifyAll() dans une méthode</ShortDescription>
  <LongDescription>Utilisation de notify() plutôt que notifyAll() dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>notify()</code> plutôt que <code>notifyAll()</code>. Le moniteur Java est souvent utilisé pour de multiples conditions. Appeler <code>notify()</code> ne réveille qu'un thread, ce qui signifie que le thread réveillé peut ne pas être celui qui attend la condition que l'appelant vient de remplir.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RV_CHECK_FOR_POSITIVE_INDEXOF">
  <ShortDescription>Méthode vérifiant que le résultat d'un String.indexOf() est positif</ShortDescription>
  <LongDescription>La méthode {1} vérifie que le résultat d'un String.indexOf() est positif</LongDescription>
  <Details>
<![CDATA[
<p>La méthode appelle <code>String.indexOf()</code> et vérifie si le résultat est strictement positif ou pas. Il est plus habituel de vérifier si le résultat est négatif. Il n'est strictement positif que lorsque la sous-chaine recherchée apparaît ailleurs qu'au début de la chaine.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RV_DONT_JUST_NULL_CHECK_READLINE">
  <ShortDescription>Méthode ignorant le résultat d'un readLine() après avoir vérifié qu'il est non nul</ShortDescription>
  <LongDescription>La méthode {1} ignore le résultat de readLine() après avoir vérifié s'il est non nul</LongDescription>
  <Details>
<![CDATA[
<p>La valeur renvoyée par <code>readLine()</code> est ignorée après avoir vérifié s'il n'est pas à <code>null</code>. Dans quasiment tous les cas, si le résultat n'est pas à <code>null</code>, vous souhaiterez utiliser cette valeur. Appeler de nouveau <code>readLine()</code> vous renverra une ligne différente.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RV_RETURN_VALUE_IGNORED">
  <ShortDescription>La méthode ignore une valeur de retour</ShortDescription>
  <LongDescription>La méthode {1} ignore la valeur renvoyée par {2}</LongDescription>
  <Details>
<![CDATA[
<p>La valeur renvoyée par cette méthode devrait-être vérifiée. Une cause habituelle de cette alarme est d'invoquer une méthode sur un objet constant en pensant que cela modifiera l'objet. Par exemple :</p>
<blockquote>
<pre>
String dateString = getHeaderField(name);
dateString.trim();
</pre>
</blockquote>
<p>Le programmeur semble croire que la méthode <code>trim()</code> mettra à jour l'objet <code>String</code> référencé par <code>dateString</code>. Mais, les objets <code>String</code> étant constants, la fonction renvoi une nouvelle valeur qui est ici ignorée. Le code devrait être corrigé en :</p>
<blockquote>
<pre>
String dateString = getHeaderField(name);
dateString = dateString.trim();
</pre>
</blockquote>
]]>
  </Details>
 </BugPattern>
  <BugPattern type="NP_ALWAYS_NULL">
  <ShortDescription>Déréférencement d'un pointeur null dans la méthode</ShortDescription>
  <LongDescription>Déréférencement d'un pointeur null dans la méthode {1}</LongDescription>
  <Details>
<![CDATA[
<p>Un pointeur à <code>null</code> est déréférencé ici. Ceci va mener à une <code>NullPointerException</code> quand le code sera exécuté.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_STORE_INTO_NONNULL_FIELD">
  <ShortDescription>Stocke une valeur null dans un champ annoté NonNull</ShortDescription>
  <LongDescription>Stocke une valeur null dans le champ {2} annoté NonNull dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur qui pourrait être à <code>null</code> est stockée dans un champ qui a été annoté comme <code>NonNull</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_ALWAYS_NULL_EXCEPTION">
  <ShortDescription>Déréférencement d'un pointeur null dans le chemin d'exception d'une méthode</ShortDescription>
  <LongDescription>Déréférencement d'un pointeur null dans le chemin d'exception de {1}</LongDescription>
  <Details>
<![CDATA[
<p>Un pointeur à <code>null</code> dans le chemin d'exception est déréférencé ici. Cela va mener à une <code>NullPointerException</code> quand le code sera exécuté. Notez que puisque FindBugs ne détecte pas les chemins d'exception irréalisables, il est possible que cette alarme soit injustifiée.</p>
<p>Notez aussi que FindBugs considère le choix par défaut d'un <code>switch</code> comme étant dans le chemin d'exception, puisque ce choix est souvent irréalisable.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NULL_ON_SOME_PATH">
  <ShortDescription>Possible déréférencement d'un pointeur null dans une méthode</ShortDescription>
  <LongDescription>Possible déréférencement d'un pointeur null dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur par référence déréférencée ici peut-être à <code>null</code> à l'exécution. Cela peut conduire à une <code>NullPointerException</code> quand le code est exécuté.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NULL_ON_SOME_PATH_EXCEPTION">
  <ShortDescription>Possible déréférencement d'un pointeur null dans le chemin d'exception d'une méthode</ShortDescription>
  <LongDescription>Possible déréférencement d'un pointeur null dans le chemin d'exception de {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur par référence qui est à <code>null</code> dans un des chemins d'exception est déréférencée ici. Ceci peut conduire à une <code>NullPointerException</code> à l'exécution du code. Notez que comme FindBugs ne repère pas les chemins d'exception irréalisables, il est possible que cette alarme soit injustifiée.</p>
<p>Notez également que FindBugs considère le cas par défaut d'un <code>switch</code> comme faisant partie du chemin d'exception puisque ce cas est souvent inattendu.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE">
  <ShortDescription>Pointeur à null renvoyé par une méthode qui risque d'être déréférencé</ShortDescription>
  <LongDescription>Un pointeur à null renvoyé par une méthode risque d'être déréférencé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>La valeur renvoyée par une méthode est déréférencée alors que cette méthode peut renvoyer <code>null</code>. Ceci peut conduire à une <code>NullPointerException</code> quand le code sera exécuté.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NULL_PARAM_DEREF_NONVIRTUAL">
  <ShortDescription>Appel à une méthode non virtuelle passant null à un paramètre déréférencé de façon inconditionnelle</ShortDescription>
  <LongDescription>Appel à une méthode non virtuelle dans {1} passant null à un paramètre déréférencé inconditionnellement dans {2}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur pouvant être à <code>null</code> est passée à une méthode qui déréférence ce paramètre de façon inconditionnelle. Cela peut se terminer en <code>NullPointerException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NULL_PARAM_DEREF_ALL_TARGETS_DANGEROUS">
  <ShortDescription>Appel de méthode passant null à un paramètre déréférencé inconditionnellement</ShortDescription>
  <LongDescription>Un appel de méthode dans {1} passe null à un paramètre déréférencé de façon inconditionnelle dans {2}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur pouvant être à <code>null</code> est passée lors d'un appel alors que toutes les méthodes cibles possibles le déréférence inconditionnellement. Cela a de fortes chances de provoquer une <code>NullPointerException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NULL_PARAM_DEREF">
  <ShortDescription>Méthode passant null à un paramètre déréférencé inconditionnellement</ShortDescription>
  <LongDescription>L'appel de méthode dans {1} passe null à un paramètre de {2} déréférencé de façon inconditionnelle</LongDescription>
  <Details>
<![CDATA[
<p>Cet appel de méthode envoie <code>null</code> à une méthode qui peut déréférencer ce paramètre de façon inconditionnelle.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NONNULL_PARAM_VIOLATION">
  <ShortDescription>Appel de méthode transmettant null à un paramètre déclaré @NonNull</ShortDescription>
  <LongDescription>Un appel de méthode dans {1} passe null à un paramètre déclaré @NonNull de {2}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode passe une valeur à <code>null</code> en paramètre d'une méthode qui a déclaré ce paramètre comme <code>@NonNull</code>.</p>
<p>Notez que la méthode avec l'annotation <code>@NonNull</code> peut être dans une sous-classe de l'objet appelé.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_NONNULL_RETURN_VIOLATION">
  <ShortDescription>Méthode renvoyer null mais déclarée @NonNull</ShortDescription>
  <LongDescription>La méthode {1} peut renvoyer null alors qu'elle est déclarée @NonNull</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode peut renvoyer une valeur à <code>null</code> alors que cette méthode (ou une méthode dérivée d'une de ses classes mère) est déclarée comme renvoyant <code>@NonNull</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="NP_GUARANTEED_DEREF">
  <ShortDescription>Null déréférencé</ShortDescription>
  <LongDescription>Une valeur à null est déréférencée dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une valeur à <code>null</code> qui est déréférencée (sauf dans les chemins impliquant une RuntimeException).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SI_INSTANCE_BEFORE_FINALS_ASSIGNED">
  <ShortDescription>Initialiseur statique de classe créant une instance avant que tous les champs static final soient alimentés</ShortDescription>
  <LongDescription>L'initialiseur statique de {0} crée une instance avant que tous les champs static final soient alimentés</LongDescription>
  <Details>
<![CDATA[
<p>L'initialiseur <code>static</code> de la classe crée une instance de la classe avant que tous les champs <code>static final</code> soient alimentés.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="OS_OPEN_STREAM">
  <ShortDescription>La méthode peut ne pas fermer un flux</ShortDescription>
  <LongDescription>La méthode {1} peut ne pas fermer un flux</LongDescription>
  <Details>
<![CDATA[
<p>La méthode crée un objet de flux d'E/S, ne l'assigne à aucun champ, ne le passe à aucune méthode, ne le renvoit pas et ne semble pas le fermer dans tous les chemins d'exécution. Ceci peut entraîner le blocage d'un descripteur de fichier. C'est généralement une bonne idée d'utiliser un bloc <code>finally</code> pour s'assurer de la fermeture des flux.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="OS_OPEN_STREAM_EXCEPTION_PATH">
  <ShortDescription>La méthode peut oublier de fermer un flux en cas d'exception</ShortDescription>
  <LongDescription>La méthode {1} peut ne pas fermer un flux en cas d'exception</LongDescription>
  <Details>
<![CDATA[
<p>La méthode crée un flux d'E/S, ne l'affecte à aucun champ, ne le passe à aucune méthode, ne le renvoit pas, et ne semble pas le fermer dans tous les chemins d'exception possibles. Ceci peut provoquer le blocage d'un descripteur de fichier. C'est généralement une bonne idée d'utiliser un bloc <code>finally</code> pour garantir la fermeture des flux.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="PZLA_PREFER_ZERO_LENGTH_ARRAYS">
  <ShortDescription>Envisagez de renvoyer un tableau vide plutôt que null</ShortDescription>
  <LongDescription>La méthode {1} devrait-elle renvoyer un tableau vide plutôt que null ?</LongDescription>
  <Details>
<![CDATA[
<p>Renvoyer un tableau vide constitue souvent une meilleure approche plutôt que de renvoyer une référence à <code>null</code> pour signaler qu'il n'y a pas de résultat (c'est-à-dire, une liste vide de résultats). De cette façon, aucune vérification explicite du <code>null</code> n'est nécessaire dans les méthodes clientes.</p>
<p>D'un autre côté, utiliser <code>null</code> signifie "il n'y a pas de réponse à cette question". Cela peut donc être approprié. Par exemple, <code>File.listFiles()</code> renvoi une liste vide si un répertoire donné ne contient pas de fichiers, et renvoi <code>null</code> si le fichier n'est pas un répertoire.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UCF_USELESS_CONTROL_FLOW">
  <ShortDescription>Instruction de contrôle du flux inutile</ShortDescription>
  <LongDescription>Instruction de contrôle du flux inutile dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une instruction de contrôle du flux inutile. Ceci est souvent provoqué par inadvertance, en utilisant un paragraphe vide comme corps d'une condition. Exemple :</p>
<pre>
if (argv.length == 1);
    System.out.println("Hello, " + argv[0]);
</pre>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE">
  <ShortDescription>Test de nullité d'une valeur préalablement déréférencée</ShortDescription>
  <LongDescription>Test de nullité dans {2} d'une valeur préalablement déréférencée dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une valeur est testée ici pour savoir si elle est à <code>null</code> alors que cette valeur ne peut pas être à <code>null</code> puisqu'elle a été déréférencée et qu'une <code>NullPointerException</code> se serait alors produite à ce moment. Ce code est en contradiction avec le déréférencement préalable au sujet de la capacité de cette valeur d'être à <code>null</code>. Soit le test est redondant, soit le déréférencement préalable est erroné.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE">
  <ShortDescription>Test de nullité redondant sur une valeur connue pour être à null</ShortDescription>
  <LongDescription>Test de nullité redondant sur une valeur connue pour être à null dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un test redondant de nullité sur une valeur ne pouvant qu'être à <code>null</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE">
  <ShortDescription>Test de nullité redondant sur une valeur non nulle</ShortDescription>
  <LongDescription>Test de nullité redondant sur une valeur non nulle dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un test redondant de nullité sur une valeur connue pour être non nulle.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RCN_REDUNDANT_COMPARISON_TWO_NULL_VALUES">
  <ShortDescription>Comparaison redondante de deux valeurs nulles</ShortDescription>
  <LongDescription>Comparaison redondante de deux valeurs nulles dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une comparaison redondante entre deux références connues pour être obligatoirement à <code>null</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RCN_REDUNDANT_COMPARISON_OF_NULL_AND_NONNULL_VALUE">
  <ShortDescription>Comparaison redondante d'une valeur non nulle avec null</ShortDescription>
  <LongDescription>Comparaison redondante d'une valeur non nulle avec null dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une comparaison entre une référence connue pour être non nulle avec une autre référence connue pour être à <code>null</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RCN_REDUNDANT_CHECKED_NULL_COMPARISON" deprecated="true">
  <ShortDescription>Comparaison redondante à null d'une valeur préalablement vérifiée</ShortDescription>
  <LongDescription>Comparaison redondante à null d'une valeur préalablement vérifiée dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une comparaison redondante d'une référence à <code>null</code>. Deux types de comparaisons redondantes sont signalés :</p>
<ul>
<li>les deux valeurs sont définitivement à <code>null</code></li>
<li>une valeur est définitivement à <code>null</code> et l'autre ne pourra jamais l'être</li>
</ul>
<p>Cette alarme signale généralement qu'une variable connue pour être différente de <code>null</code> est comparée avec <code>null</code>. Bien que le test ne soit pas nécessaire, ce peut-être un simple cas de programmation défensive.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UL_UNRELEASED_LOCK">
  <ShortDescription>La méthode ne libère pas un verrou dans tous les chemins d'exécution</ShortDescription>
  <LongDescription>La méthode {1} ne libère pas un verrou dans tous les chemins d'exécution</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode acquière un verrou JSR-166 (<code>java.util.concurrent</code>), mais ne le libère pas dans tous les chemins d'exécution. En général, l'idiome correct pour utiliser un verrou JSR-166 est :</p>
<pre>
Lock l = ...;
l.lock();
try {
    // do something
} finally {
    l.unlock();
}
</pre>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UL_UNRELEASED_LOCK_EXCEPTION_PATH">
  <ShortDescription>La méthode ne libère pas un verrou dans tous les chemins d'exception</ShortDescription>
  <LongDescription>La méthode {1} ne libère pas un verrou dans tous les chemins d'exception</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode acquière un verrou JSR-166 (<code>java.util.concurrent</code>), mais ne le libère pas dans tous les chemins d'exception. En général, l'idiome correct pour utiliser un verrou JSR-166 est :</p>
<pre>
Lock l = ...;
l.lock();
try {
    // do something
} finally {
    l.unlock();
}
</pre>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RC_REF_COMPARISON">
  <ShortDescription>Comparaison de références suspecte</ShortDescription>
  <LongDescription>Comparaison suspecte des références {3} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode compare deux références avec l'opérateur <code>==</code> ou <code>!=</code>, alors que la façon correcte de comparer les instances de ce type est généralement d'utiliser la méthode <code>equals()</code>. Des exemples de classes qui ne doivent généralement pas être comparées par référence sont <code>java.lang.Integer</code>, <code>java.lang.Float</code>, etc...</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EC_UNRELATED_TYPES">
  <ShortDescription>Appel de equals() comparant des types différents</ShortDescription>
  <LongDescription>Appel de equals() comparant des types différents dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>equals(Object)</code> pour deux références de type différents, sans sous-classe commune. Les objets comparés ne sont donc probablement pas de la même classe à l'éxécution (au moins que certaines classes de l'application n'aient pas été analysées ou qu'il y ait des chargements dynamiques). D'après le contrat de <code>equals()</code>, les objets de classes différentes devraient toujours être inégaux, c'est pourquoi la comparaison a de fortes chances de toujours renvoyer <code>false</code> à l'exécution.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EC_UNRELATED_INTERFACES">
  <ShortDescription>Appel de equals() comparant différentes interfaces</ShortDescription>
  <LongDescription>Appel de equals() comparant différents types d'interface dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>equals(Object)</code> pour deux références d'interfaces sans rapport, aucune n'étant un sous-type de l'autre et aucune classe non abstraite implémentant les deux interfaces. Les objets comparés ne sont donc probablement pas de la même classe à l'éxécution (au moins que certaines classes de l'application n'aient pas été analysées ou qu'il y ait des chargements dynamiques). D'après le contrat de <code>equals()</code>, les objets de classes différentes devraient toujours être inégaux.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EC_UNRELATED_CLASS_AND_INTERFACE">
  <ShortDescription>Appel de equals() comparant une classe et une interface sans relation</ShortDescription>
  <LongDescription>Appel de equals() comparant une classe et une interface sans relation dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>equals(Object)</code> sur deux références, l'une de classe, l'autre d'interface, alors que ni la classe, ni aucune de ses sous classes abstraites n'implémente l'interface. Les objets comparés ne font donc probablement pas partie de la même hiérarchie de classe à l'exécution (à moins que certaines classes de l'application n'est pas été analysées ou soient chargées dynamiquement à l'exécution). En accord avec le contrat de <code>equals()</code>, des objets de classes différentes doivent toujours être non égaux, donc le résultat de cette comparaison par <code>java.lang.Object.equals(Object)</code> renverra systèmatiquement <code>false</code> à l'exécution.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EC_NULL_ARG">
  <ShortDescription>Appel de equals() avec un argument à null</ShortDescription>
  <LongDescription>Appel de equals() avec un argument à null dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>equals(Object)</code>, passant une valeur à <code>null</code> comme argument. D'après le contrat de la méthode <code>equals()</code>, cet appel devrait systématiquement renvoyer <code>false</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MWN_MISMATCHED_WAIT">
  <ShortDescription>wait() non appareillé</ShortDescription>
  <LongDescription>wait() non appareillé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>Object.wait()</code> sans détenir, visiblement, de verrou sur l'objet. Appeler <code>wait()</code> sans détenir de verrou entraîne le déclenchement d'une <code>IllegalMonitorStateException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MWN_MISMATCHED_NOTIFY">
  <ShortDescription>notify() non appareillé</ShortDescription>
  <LongDescription>notify() non appareillé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>Object.notify()</code> ou <code>Object.notifyAll()</code> sans détenir, visiblement, de verrou sur l'objet. Appeler <code>notify()</code> ou <code>notifyAll()</code> sans détenir de verrou entraîne le déclenchement d'une <code>IllegalMonitorStateException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SA_LOCAL_SELF_ASSIGNMENT">
  <ShortDescription>Auto-alimentation d'une variable locale</ShortDescription>
  <LongDescription>Auto-alimentation d'une variable locale dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une auto-alimentation d'une variable locale, par exemple :</p>
<pre>
public vida foo() {
  int x = 3;
  x = x;
}
</pre>
<p>De telles affectations sont inutiles et peuvent indiquer une faute de frappe ou une erreur de logique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SA_FIELD_SELF_ASSIGNMENT">
  <ShortDescription>Auto-alimentation d'un champs</ShortDescription>
  <LongDescription>Auto-alimentation du champs {2} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient un champ s'auto-alimentant; par exemple :</p>
<pre>
int x;
public void foo() {
  x = x;
}
</pre>
<p>De telles affectations sont inutiles et peuvent indiquer une faute de frappe ou une erreur logique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RV_REM_OF_RANDOM_INT">
  <ShortDescription>Reste d'un entier signé 32 bits aléeatoire</ShortDescription>
  <LongDescription>Reste d'un entier signé 32 bits aléeatoire calculé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code génère un entier signé aléatoire puis calcule le reste de cette valeur modulo une autre valeur. Puisque ce nombre aléatoire peut être négatif, le reste de l'opération peut également l'être. Soyez sûr que c'est voulu, et envisagez d'utiliser à la place la méthode <code>Random.nextInt(int)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RV_REM_OF_HASHCODE">
  <ShortDescription>Reste d'un hashCode pouvant être négatif</ShortDescription>
  <LongDescription>Le reste d'un hashCode peut être négatif dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code calcule le code de hachage, puis son reste modulo une certaine valeur. Puisque le code de hachage peut être négatif, le reste peut également l'être.</p>
<p>En supposant que vous vouliez garantir que le résultat de votre opération ne soit pas négatif, vous devriez modifier votre code. Si le diviseur est une puissance de 2, vous pourriez utiliser un décalage binaire à la place (c'est-à-dire <code>x.hashCode()&amp;(n-1)</code> au lieu de <code>x.hashCode()%n</code>). Cela est probablement plus rapide que de calculer le reste. Si le diviseur n'est pas une puissance de 2, vous devriez prendre la valeur absolue du reste (<code>Math.abs(x.hashCode()%n)</code>).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="INT_VACUOUS_COMPARISON">
  <ShortDescription>Comparaison inutile de valeurs entières</ShortDescription>
  <LongDescription>Comparaison inutile de la valeur entière {1}</LongDescription>
  <Details>
<![CDATA[
<p>Il y a une comparaison entière qui renvoie toujours la même valeur (Ex. : <code>x <= Integer.MAX_VALUE</code>).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="INT_BAD_REM_BY_1">
  <ShortDescription>Reste entier modulo 1</ShortDescription>
  <LongDescription>Reste entier modulo 1 calculé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette expression (Ex. : <code>exp % 1</code>) est assurée de toujours renvoyer 0. Vouliez-vous plutot dire <code>(exp & 1)</code> ou <code>(exp % 2)</code> ?</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BIT_IOR_OF_SIGNED_BYTE">
  <ShortDescription>Ou binaire d'un octet signé</ShortDescription>
  <LongDescription>Ou binaire d'un octet signé calculé dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Charge une valeur à partir d'un tableau d'octets et effectue un ou binaire sur cette valeur. Les valeurs venant d'un tableau d'octet sont signées et risquent donc de ne pas se comporter comme prévue.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BIT_AND">
  <ShortDescription>Masques binaires incompatibles</ShortDescription>
  <LongDescription>Des masques binaires incompatibles renvoient un résultat constant dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode compare une expression de la forme (a <code>&amp;</code> C) avec D, qui est toujours inégale en raison des valeurs spécifiques des constantes C et D. Cela peut indiquer une faute de frappe ou une erreur logique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BIT_AND_ZZ">
  <ShortDescription>Masques binaires incompatibles</ShortDescription>
  <LongDescription>Des masques binaires incompatibles renvoient un résultat constant dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode compare une expression de la forme (a <code>&amp;</code> 0) avec 0, qui est toujours égale. Ceci peut indiquer une faute de frappe ou une erreur logique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BIT_IOR">
  <ShortDescription>Masques binaires incompatibles</ShortDescription>
  <LongDescription>Des masques binaires incompatibles renvoient un résultat constant dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode compare une expression de la forme (a <code>|</code> C) avec D, qui est toujours inégale en raison des valeurs spécifiques des constantes C et D. Ceci peut indiquer une erreur logique ou une faute de frappe.</p>
<p>Typiquement, ce bogue arrive quand du code essaye d'effectuer un test d'apparition d'un bit mais utilise l'opérateur OU ("<code>|</code>") au lieu de l'opérateur ET ("<code>&amp;</code>").</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="LI_LAZY_INIT_INSTANCE" deprecated="true">
  <ShortDescription>Initialisation paresseuse incorrecte d'un champ d'instance</ShortDescription>
  <LongDescription>Initialisation paresseuse incorrecte du champ d'instance {2} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une initialisation paresseuse non synchronisée d'un champ non <code>volatile</code>. Comme le compilateur ou le processeur peuvent réordonner les instructions, les threads ne sont pas certains de voir un objet complètement initialisé, <em>si la méthode peut-être appelée par de multiples threads</em>. Vous pouvez rendre le champs <code>volatile</code> pour corriger le problème. Pour plus d'informations, cf. <a href="http://www.cs.umd.edu/~pugh/java/memoryModel/">site Web sur le modèle mémoire de Java</a>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="LI_LAZY_INIT_STATIC">
  <ShortDescription>Initialisation paresseuse incorrecte d'un champ statique</ShortDescription>
  <LongDescription>Initialisation paresseuse incorrecte du champ statique {2} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode contient une initialisation paresseuse non synchronisée d'un champ statique non <code>volatile</code>. Comme le compilateur ou le processeur peuvent réordonner les instructions, les threads ne sont pas certains de voir un objet complètement initialisé, <em>si la méthode peut-être appelée par de multiples threads</em>. Vous pouvez rendre le champs <code>volatile</code> pour corriger le problème. Pour plus d'informations, cf. <a href="http://www.cs.umd.edu/~pugh/java/memoryModel/">site Web sur le modèle mémoire de Java</a>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="JLM_JSR166_LOCK_MONITORENTER">
  <ShortDescription>Synchronisation effectuée sur un Lock java.util.concurrent</ShortDescription>
  <LongDescription>Synchronisation effectuée sur un Lock java.util.concurrent dans la méthode {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode se synchronise au moyen d'une implémentation de <code>java.util.concurrent.locks.Lock</code>. Vous devriez plutôt utiliser les méthodes <code>lock()</code> et <code>unlock()</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UPM_UNCALLED_PRIVATE_METHOD">
  <ShortDescription>Méthode privée jamais appelée</ShortDescription>
  <LongDescription>La méthode privée {1} n'est jamais appelée</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode privée n'est jamais appelée. Bien qu'il soit possible que cette méthode soit appelée par réflexion, il y a plus de chances qu'elle ne soit jamais utilisée et qu'elle puisse être supprimée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS">
  <ShortDescription>Méthode non appelable définie dans une classe anonyme</ShortDescription>
  <LongDescription>La méthode inaccessible {1} est définie dans une classe anonyme</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe anonyme définie une méthode qui n'est pas directement appelée et qui ne surcharge pas une méthode de la classe mère. Puisque les méthodes des autres classes ne peuvent pas directement invoquer les méthodes des classes anonymes, il apparaît que cette méthode est inaccessible. Cette méthode est probablement du code mort, mais il est aussi possible qu'elle essaye de surcharger une méthode déclarée dans la classe mère et échoue à le faire en raison d'une erreur de type ou autre.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ODR_OPEN_DATABASE_RESOURCE">
  <ShortDescription>La méthode peut ne pas fermer une ressource base de données</ShortDescription>
  <LongDescription>La méthode {1} peut ne pas fermer une ressource base de données</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode crée une ressource base de données (telle qu'une connexion ou un <code>RowSet</code>), ne l'affecte à aucun champ, ne la passe à aucune autre méthode, ne la renvoie pas, et ne semble pas la fermer dans tous les chemins d'exécution. Ne pas fermer une ressource base de données dans tous les chemins d'exécution peut entraîner de faibles performances et poser des problèmes de communication entre la base de données et l'application.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ODR_OPEN_DATABASE_RESOURCE_EXCEPTION_PATH">
  <ShortDescription>La méthode peut ne pas fermer une ressource base de données sur une exception</ShortDescription>
  <LongDescription>La méthode {1} peut ne pas fermer une ressource de base de données en cas d'exception</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode crée une ressource base de données (telle qu'une connexion ou un <code>RowSet</code>), ne l'affecte à aucun champ, ne la passe à aucune autre méthode, ne la renvoie pas, et ne semble pas la fermer dans tous les chemins d'exception. Ne pas fermer une ressource base de données peut entraîner de faibles performances et poser des problèmes de communication entre la base de données et l'application.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SBSC_USE_STRINGBUFFER_CONCATENATION">
  <ShortDescription>La méthode concatène des chaînes au moyen de + en boucle</ShortDescription>
  <LongDescription>La méthode {1} concatène des chaînes au moyen de + en boucle</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode semble construire une <ocde>String</code> en utilisant une concaténation en boucle. A chaque itération, l'objet <code>String</code> est converti en <code>StringBuffer</code>/<code>StringBuilder</code>, complété, puis de nouveau converti en <code>String</code>. Ceci a un coût exponentiel en fonction du nombre d'itérations, puisque la chaîne est recopiée à chaque itération.</p>
<p>De meilleurs performances peuvent être obtenues en utilisant explicitement <code>StringBuffer</code> (ou <code>StringBuilder</code> en Java 5).</p>
<p>Par exemple :</p>
<pre>
// C'est mal !
String s = "";
for (int i = 0; i &lt; field.length; ++i) {
  s = s + field[i];
}

// C'est mieux...
StringBuffer buf = new StringBuffer();
for (int i = 0; i &lt; field.length; ++i) {
  buf.append(field[i]);
}
String s = buf.toString();
</pre>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ITA_INEFFICIENT_TO_ARRAY">
  <ShortDescription>La méthode utilise toArray() avec un tableau vide en paramètre</ShortDescription>
  <LongDescription>La méthode {1} utilise Collection.toArray() avec un tableau vide en paramètre</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode utilise la méthode <code>toArray()</code> d'une classe dérivant de <code>Collection</code>, en lui passant en paramètre un tableau vide. Il est plus efficace d'utiliser <code>myCollection.toArray(new Foo[myCollection.size()])</code>. Si le tableau transmis est assez grand pour stocker tous les éléments de la collection, alors il est alimenté et renvoyé directement. Ceci évite la nécessité de créer un nouveau tableau (par réflexion) pour renvoyer le résultat.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IJU_SETUP_NO_SUPER">
  <ShortDescription>Une classe dérivant de TestCase implémente setUp() sans appeler super.setUp()</ShortDescription>
  <LongDescription>La classe {0} dérivant de TestCase implémente setUp() sans appeler super.setUp()</LongDescription>
  <Details>
<![CDATA[
<p>La classe dérive de la classe <code>TestCase</code> de JUnit est implémente la méthode <code>setUp()</code>. La méthode <code>setUp()</code> devrait appeler <code>super.setUp()</code>, mais ne le fait pas.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IJU_TEARDOWN_NO_SUPER">
  <ShortDescription>Une classe dérivant de TestCase implémente tearDown() sans appeler super.tearDown()</ShortDescription>
  <LongDescription>La classe {0} dérivant de TestCase implémente tearDown() sans appeler super.tearDown()</LongDescription>
  <Details>
<![CDATA[
<p>La classe dérive de la classe <code>TestCase</code> de JUnit et implémente la méthode <code>tearDown()</code>. La méthode <code>tearDown()</code> devrait appeler <code>super.tearDown()</code>, mais ne le fait pas.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IJU_SUITE_NOT_STATIC">
  <ShortDescription>Une classe dérivant de TestCase implémente une méthode suite() non statique</ShortDescription>
  <LongDescription>La classe {0} dérivant de TestCase implémente une méthode suite() non statique</LongDescription>
  <Details>
<![CDATA[
<p>La classe dérive de <code>TestCase</code> de JUnit et implémente une méthode <code>suite()</code>. La méthode <code>suite()</code> devrait-être déclarée comme étant <code>static</code>, ce qui n'est pas fait.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IJU_NO_TESTS">
  <ShortDescription>TestCase sans tests</ShortDescription>
  <LongDescription>TestCase {0} n'a pas de tests</LongDescription>
  <Details>
<![CDATA[
<p>La classe JUnit <code>TestCase</code> n'implémente aucune méthode de test.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BOA_BADLY_OVERRIDDEN_ADAPTER">
  <ShortDescription>La classe surcharge mal une méthode implémentée dans une superclasse Adapter</ShortDescription>
  <LongDescription>La classe {0} surcharge mal la méthode {1} implémentée dans une superclasse Adapter</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode surcharge une méthode provenant d'une classe mère qui est un <code>Adapter</code> qui implémente un <code>Listener</code> défini dans le paquetage <code>java.awt.event</code> ou <code>javax.swing.event</code>. En conséquence, cette méthode ne sera pas appelée quand l'évènement se produira.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BRSA_BAD_RESULTSET_ACCESS" deprecated="true">
  <ShortDescription>La méthode essaye d'accéder à un champ de ResultSet avec l'index 0</ShortDescription>
  <LongDescription>La méthode {1} essaye au champ d'index 0 d'un ResultSet</LongDescription>
  <Details>
<![CDATA[
<p>Un appel à la méthode <code>getXXX()</code> ou <code>updateXXX()</code> d'un <code>ResultSet</code> est effectué avec l'index de champ 0. Comme l'index des champs de <code>ResultSet</code> commence à 1 c'est toujours une erreur.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SQL_BAD_RESULTSET_ACCESS">
  <ShortDescription>Méthode essayant d'accèder à un champ de ResultSet d'indice 0</ShortDescription>
  <LongDescription>La méthode {1} essaye d'accèder au champ d'un ResultSet avec l'indice 0</LongDescription>
  <Details>
<![CDATA[
<p>Un appel à une méthode <code>getXXX</code> ou <code>updateXXX</code> d'un <code>ResultSet</code> est réalisé pour l'indice 0. Puisque les indices de <code>ResultSet</code> commencent à 1, c'est toujours une erreur.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SQL_BAD_PREPARED_STATEMENT_ACCESS">
  <ShortDescription>Méthode essayant au paramêtre d'indice 0 d'un PreparedStatement</ShortDescription>
  <LongDescription>La méthode {1} essaye d'accèder au paramêtre d'indice 0 d'un PreparedStatement</LongDescription>
  <Details>
<![CDATA[
<p>Un appel  à une méthode <code>setXXX</code> d'un <code>PreparedStatement</code> est réalisé sur l'indice 0. Puisque les indices des paramêtres d'un <code>PreparedStatement</code> commencent à 1, c'est toujours une erreur.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SIO_SUPERFLUOUS_INSTANCEOF">
  <ShortDescription>Vérification de type inutile avec l'opérateur instanceof</ShortDescription>
  <LongDescription>La méthode {1} effectue une vérification de type inutile avec l'opérateur instanceof alors que cela pourrait-être déterminé statiquement</LongDescription>
  <Details>
<![CDATA[
<p>Vérification de type effectuée avec l'opérateur <code>instanceof</code> alors que cela pourrait-être déterminé statiquement.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BAC_BAD_APPLET_CONSTRUCTOR">
  <ShortDescription>Constructeur d'Applet erroné reposant sur un AppletStub non initialisé</ShortDescription>
  <LongDescription>Constructeur d'Applet erroné reposant sur un AppletStub non initialisé</LongDescription>
  <Details>
<![CDATA[
<p>Ce constructeur appelle des méthodes de l'applet mère qui repose sur l'AppletStub. Comme l'AppletStub n'est pas initialisé jusqu'à ce que la méthode <code>init()</code> de cette applet soit appelée, ces méthodes ne se comporteront pas correctement.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EC_ARRAY_AND_NONARRAY">
  <ShortDescription>Utilisation de equals() pour comparer un tableau et un objet</ShortDescription>
  <LongDescription>La méthode {1} utilise equals() pour comparer un tableau et un objet</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>equals(Object o)</code> pour comparer un tableau et une référence qui ne semble pas être un tableau. Si les choses comparées sont de type différents, il est garanti qu'elles seront non égales et la comparaison est probablement une erreur. Même si les deux sont des tableaux, la méthode <code>equals()</code> détermine seulement si les deux tableaux sont le même objet. Pour comparer le contenu de deux tableaux, utilisez <code>java.util.Arrays.equals(Object[], Object[])</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="EC_BAD_ARRAY_COMPARE">
  <ShortDescription>Appel à equals() sur un tableau équivalent à ==</ShortDescription>
  <LongDescription>Les appels à equals sur un tableau sont équivalents à ==</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode invoque la méthode <code>equals(Object o)</code> d'un tableau. Comme les tableaux ne surchargent pas la méthode <code>equals()</code> de <code>Object</code>, cet appel revient à comparer les adresses. Pour comparer les contenus de tableaux, utilisez <code>java.util.Arrays.equals(Object[], Object[])</code>.</p>
]]>
  </Details>
 </BugPattern>
  <BugPattern type="STI_INTERRUPTED_ON_CURRENTTHREAD">
  <ShortDescription>Utilisation superflue d'un appel à currentThread() pour appeler interrupted()</ShortDescription>
  <LongDescription>La méthode {1} invoque inutilement currentThread() juste pour appeler interrupted()</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode invoque <code>Thread.currentThread()</code> juste pour appeler la méthode <code>interrupted()</code>. Comme <code>interrupted()</code> est une méthode statique, il est plus simple et facile d'utiliser <code>Thread.interrupted()</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="STI_INTERRUPTED_ON_UNKNOWNTHREAD">
  <ShortDescription>Thread.interrupted() appelée par erreur sur un objet Thread arbitraire</ShortDescription>
  <LongDescription>La méthode {1} utilise la méthode statique Thread.interrupted(), essayant par erreur de l'appeler sur un objet Thread arbitraire.</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode invoque <code>Thread.interrupted()</code> sur un objet <code>Thread</code> qui n'est pas le thread actif. Pusique la méthode <code>interrupted()</code> est statique, la méthode <code>interrupted()</code> sera appelée sur un objet différent de celui auquel l'auteur du code pensait.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IP_PARAMETER_IS_DEAD_BUT_OVERWRITTEN">
  <ShortDescription>Un paramètre est ré-écrit avant d'être utilisé</ShortDescription>
  <LongDescription>Un paramètre de {1} est écrasé avant d'être utilisé</LongDescription>
  <Details>
<![CDATA[
<p>La valeur initiale de ce paramètre est ignorée, et le paramètre est écrasé. Ceci indique généralement une erreur provenant de la croyance infondée qu'une écriture sur ce paramètre sera transmise à l'appelant.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DLS_DEAD_LOCAL_STORE">
  <ShortDescription>Alimentation à perte d'une variable locale</ShortDescription>
  <LongDescription>Alimentation à perte d'une variable locale dans la méthode {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette instruction assigne une valeur à une variable locale mais cette variable n'est pas lue par la suite. Ceci indique souvent une erreur puisque la valeur calculée n'est jamais utilisée.</p>
<p>Notez que le compilateur javac de Sun génère fréquemment ce genre d'affectations à perte. FindBugs analysant le byte-code généré, il n'y a pas de façon simple d'éliminer ces fausses alarmes.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DLS_DEAD_LOCAL_STORE_OF_NULL">
  <ShortDescription>Alimentation à null d'une variable</ShortDescription>
  <LongDescription>Alimentation à null de {2} dans la méthode {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code alimente une variable locale avec null, la valeur n'étant jamais lue par la suite. Cette alimentation a pu être introduite pour faciliter le travail du ramasse-miettes, mais cela n'a plus aucun intérêt avec Java SE 6.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MF_METHOD_MASKS_FIELD">
  <ShortDescription>La méthode définit une variable qui masque un champ</ShortDescription>
  <LongDescription>La méthode {1} définit une variable qui masque le champ {2}</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode définit une variable locale ayant le même nom qu'un champ de la classe ou d'une classe mère. Ceci peut pousser la méthode à lire une valeur non initialisée dans le champs, à le laisser non initialisé ou les deux.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MF_CLASS_MASKS_FIELD">
  <ShortDescription>La classe définit un champ qui masque un champ d'une classe mère</ShortDescription>
  <LongDescription>La classe {0} définit un champ qui masque le champ {1} d'une classe mère</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe définit un champ avec le même nom qu'un champ visible d'instance d'une classe mère. C'est ambigu et peut entraîner une erreur si des méthodes mettent à jour ou accèdent à un des champs alors qu'elles souhaitaient utiliser l'autre.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="WMI_WRONG_MAP_ITERATOR">
  <ShortDescription>Utilisation inefficace d'un itérateur sur keySet au lieu de entrySet</ShortDescription>
  <LongDescription>La méthode {1} fait une utilisation inefficace d'un itérateur sur keySet au lieu d'un itérateur sur entrySet</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode accède à la valeur d'une entrée de <code>Map</code> au moyen d'une clé provenant d'un itérateur sur <code>keySet</code>. Il est plus efficace d'utiliser un itérateur sur l'<code>entrySet</code> de la <code>Map</code>, pour éviter la recherche par <code>Map.get(clé)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ISC_INSTANTIATE_STATIC_CLASS">
  <ShortDescription>Instantiation inutile d'une classe qui n'a que des méthodes statiques</ShortDescription>
  <LongDescription>La méthode {1} instancie une classe qui n'a que des méthodes statiques</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe alloue un objet basé sur une classe qui n'a que des méthodes statiques. Cet objet n'a pas besoin d'être créé, accédez directement aux méthodes en utilisant le nom de la classe.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="REC_CATCH_EXCEPTION">
  <ShortDescription>java.lang.Exception est intercepté alors qu'Exception n'est jamais lancé</ShortDescription>
  <LongDescription>La méthode {1} intercepte Exception, mais Exception n'est pas lancé dans le bloc try/catch et RuntimeException n'est pas appelé</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode utilise un block <code>try-catch</code> qui intercepte les objets <code>Exception</code>, mais <code>Exception</code> n'est jamais déclenché dans ce bloc, et <code>RuntimeException</code> n'est pas explicitement intercepté.  C'est une erreur commune de dire que <code>try / catch (Exception e)</code> est identique à plusieurs <code>try / catch</code>, mais cette tournure intercepte également les <code>RuntimeException</code>, masquant des bugs potentiels.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FE_TEST_IF_EQUAL_TO_NOT_A_NUMBER">
  <ShortDescription>Test d'égalité avec NaN erroné</ShortDescription>
  <LongDescription>Test d'égalité avec NaN erroné dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code vérifie si une valeur flottante est égale à la valeur spéciale "Not A Number" (Ex. : <code>if (x == Double.NaN)</code>). La sémantique de <code>NaN</code> fait que, par définition, aucune valeur n'est égale à <code>Nan</code>, y compris <code>NaN</code>. Donc <code>x == Double.NaN</code> renvoi systématiquement <code>false</code>.</p>
<p>Pour savoir si la valeur contenu dans <code>x</code> est la valeur particulière "Not A Number", utilisez <code>Double.isNaN(x)</code> (ou <code>Float.isNaN(x)</code> si <code>x</code> est en simple précision).</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="FE_FLOATING_POINT_EQUALITY">
  <ShortDescription>Test d'égalité en virgule flottante.</ShortDescription>
  <LongDescription>Test d'égalité en virgule flottante dans {1}.</LongDescription>
  <Details>
<![CDATA[
<p>Cette opération teste l'égalité de deux valeurs en virgule flottante. Les calculs en virgule flottante pouvant introduire des arrondis, les valeurs flottantes ou doubles peuvent être imprécises. Pour les valeurs qui doivent être précises, telles que les valeurs monétaires, pensez à utiliser un type à précision fixe tel qu'un <code>BigDecimal</code>. Pour les valeurs qui n'ont pas besoin d'être précises, pensez à tester l'égalité sur une portée quelconque, par exemple : <code>if ( Math.abs(x - y) &lt; .0000001 )</code>. Cf section 4.2.4 des spécifications du langage Java.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="UM_UNNECESSARY_MATH">
  <ShortDescription>Appel d'une méthode statique de la classe Math sur une valeur constante</ShortDescription>
  <LongDescription>Appel d'une méthode statique de la classe Math sur une valeur constante</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode utilise une méthode statique de <code>java.lang.Math</code> sur une valeur constante. Dans ce cas, le résultat de cet appel peut être déterminé statiquement, ce qui est plus rapide et souvent plus précis. Les méthodes détectées sont :</p>
<table>
<tr><th>Méthode</th><th>Paramètre</th></tr>
<tr><td>abs</td><td>-tous-</td></tr>
<tr><td>acos</td><td>0.0 ou 1.0</td></tr>
<tr><td>asin</td><td>0.0 ou 1.0</td></tr>
<tr><td>atan</td><td>0.0 ou 1.0</td></tr>
<tr><td>atan2</td><td>0.0</td></tr>
<tr><td>cbrt</td><td>0.0 ou 1.0</td></tr>
<tr><td>ceil</td><td>-tous-</td></tr>
<tr><td>cos</td><td>0.0</td></tr>
<tr><td>cosh</td><td>0.0</td></tr>
<tr><td>exp</td><td>0.0 ou 1.0</td></tr>
<tr><td>expm1</td><td>0.0</td></tr>
<tr><td>floor</td><td>-tous-</td></tr>
<tr><td>log</td><td>0.0 ou 1.0</td></tr>
<tr><td>log10</td><td>0.0 ou 1.0</td></tr>
<tr><td>rint</td><td>-tous-</td></tr>
<tr><td>round</td><td>-tous-</td></tr>
<tr><td>sin</td><td>0.0</td></tr>
<tr><td>sinh</td><td>0.0</td></tr>
<tr><td>sqrt</td><td>0.0 ou 1.0</td></tr>
<tr><td>tan</td><td>0.0</td></tr>
<tr><td>tanh</td><td>0.0</td></tr>
<tr><td>toDegrees</td><td>0.0 ou 1.0</td></tr>
<tr><td>toRadians</td><td>0.0</td></tr>
</table>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="CD_CIRCULAR_DEPENDENCY">
  <ShortDescription>Dépendance circulaire entre des classes</ShortDescription>
  <LongDescription>La classe {0} a une dépendance circulaire avec d'autre classes</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe a une dépendance circulaire avec d'autres classes. Ceci rend la compilation de ces classes difficile puisque chaque classe est dépendante de l'autre pour être correctement construite. Pensez à utiliser des interfaces pour briser la dépendance circulaire forte.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RI_REDUNDANT_INTERFACES">
  <ShortDescription>Classe implémentant la même interface que sa super-classe</ShortDescription>
  <LongDescription>La classe {0} implémente la même interface que sa classe mère</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe déclare implémenter une interface qui est aussi implémentée par une de ses classes mères. Ceci est redondant : dès qu'une super-classe implémente une interface, toutes les sous-classes le font aussi par défaut. Cela peut indiquer que la hiérarchie d'héritage a changé depuis la création de cette classe et la cible de l'implémentation de l'interface doit peut-être être reprise en considération.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MTIA_SUSPECT_STRUTS_INSTANCE_FIELD">
  <ShortDescription>La classe hérite d'une classe action Struts et utilise les variables de l'instance.</ShortDescription>
  <LongDescription>La classe {0} hérite d'une classe action Struts et utilise les variables de l'instance.</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe hérite d'une classe <code>Action</code> Struts, et utilise une variable de cette instance. Puisqu'une seule instance de la classe <code>Action</code> Struts est créée par le cadre de travail Struts, et est utilisée dans un environnement multitâche, ce paradigme est très fortement découragé et très certainement problématique. Considérer l'emploi seul de variables propres à la méthode.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="MTIA_SUSPECT_SERVLET_INSTANCE_FIELD">
  <ShortDescription>La classe hérite de Servlet et utilise les variables de l'instance.</ShortDescription>
  <LongDescription>La classe {0} hérite de Servlet et utilise les variables de l'instance.</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe hérite de la classe <code>Servlet</code>, et utilise une variable de l'instance. Puisqu'une seule instance d'une classe <code>Servlet</code> est créée par le cadre de travail J2EE, et est utilisée dans un environnement multitâche, ce paradigme est très fortement découragé et très certainement problématique. Considérer l'emploi seul de variables propres à la méthode.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="PS_PUBLIC_SEMAPHORES">
  <ShortDescription>La classe expose sa synchronisation et ses sémaphores dans son interface publique.</ShortDescription>
  <LongDescription>La classe {0} expose sa synchronisation et ses sémaphores dans son interface publique.</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe utilise la synchronisation avec with <code>wait()</code>, <code>notify()</code> or <code>notifyAll()</code> sur elle-même (la référence <code>this</code>). Les classes qui utilise cette classes peuvent de plus utiliser une instance de cette classe comme un objet de synchronisation. Du fait que deux classes peuvent utiliser le même objet pour la synchronisation, la cohérence en environnement multitâche devient suspecte. Vous ne devriez synchroniser ni appeler de méthodes de sémaphores sur une référence publique. Considérer l'utilisation d'une varible interne privée pour contrôler la synchronisation.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ICAST_INTEGER_MULTIPLY_CAST_TO_LONG">
  <ShortDescription>Résultat d'une multiplication entière transtypée en long</ShortDescription>
  <LongDescription>Le résultat d'une multiplication entière est transtypée en long dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code effectue des multiplications entières et transtype le résultat en <code>long</code>, comme dans :
<code>long convertDaysToMilliseconds(int days) { return 1000*3600*24*days; }</code>. Si la multiplication était réalisée en utilisant l'arithmétique <code>long</code>, vous pourriez éviter le risque de débordement de capacité du calcul. Vous pouvez par exemple corriger le code précédent par : <code>long convertDaysToMilliseconds(int days) { return 1000L*3600*24*days; }</code> ou <code><pre>
static final long MILLISECONDS_PER_DAY = 24L*3600*1000;
long convertDaysToMilliseconds(int days) { return days * MILLISECONDS_PER_DAY; } 
</pre></code></p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ICAST_INT_CAST_TO_FLOAT_PASSED_TO_ROUND">
  <ShortDescription>Valeur entière transtypée en flottant puis transmise à Math.round</ShortDescription>
  <LongDescription>Une valeur entière est transtypée en flottant puis transmise à Math.round dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code converti une valeur entière en flottant simple précision puis la passe à la méthode <code>Math.round()</code> qui renvoi l'<code>int</code> ou le <code>long</code> le plus proche de son paramètre. Cette opération doit toujours revenir à ne rien faire, puisque le transtypage d'un entier en un flottant devrait systématiquement donner un flottant sans partie décimale. Il est probable que l'opération gérant la valeur passée à <code>Math.round()</code> devrait être effectuée en arithmétique flottante.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ICAST_INT_CAST_TO_DOUBLE_PASSED_TO_CEIL">
  <ShortDescription>Valeur entière transtypée en nombre flottant passée à Math.ceil</ShortDescription>
  <LongDescription>Une valeur entière est transtypée en nombre flottant puis passée à Math.ceil dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code convertit une valeur entière en nombre flottant à double précision et passe le résultat à la méthode <code>Math.ceil()</code>, qui arrondit un nombre flottant à sa valeur entière immédiatement supérieure. Cette opération n'a pas de raison d'être, puisque le transtypage d'un entier en double donne un nombre sans valeur après la virgule. Il est vraissemblable que l'opération qui a créé la valeur pour la passer à <code>Math.ceil</code> visait l'utilisation de l'arithmétique sur un nombre flottant en double précision.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ICAST_IDIV_CAST_TO_DOUBLE">
  <ShortDescription>Résultat d'une division entière transtypé en nombre flottant</ShortDescription>
  <LongDescription>Résultat d'une division entière transtypé en nombre flottant à double précision dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code transtype le résultat d'une division entière en un nombre flottant à double précision. Effectuer une division sur des nombres entiers n'est pas précis. Le fait que le résultat soit transtypé en <code>double</code> suggère que cette précision était voulue dès le départ. Peut être l'un ou l'autre des opérandes, ou les deux opérandes, auraient du être transtypé avant d'effectuer la division. Voici un exemple :</p>
<blockquote>
<pre>
int x = 2;
int y = 5;
// Faux: renvoi 0.0
double value1 =  x / y;

// Juste: renvoi 0.4
double value2 =  x / (double) y;
</pre>
</blockquote>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="J2EE_STORE_OF_NON_SERIALIZABLE_OBJECT_INTO_SESSION">
  <ShortDescription>Stockage d'un objet non serialisable dans une session Http</ShortDescription>
  <LongDescription>Stockage de l'objet non sérialisable {3} dans la session Http de {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code semble stocker un objet non sérialisable dans un <code>HttpSession</code>. Une erreur se produira si cette session est rendue passive ou migrée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_NONSERIALIZABLE_OBJECT_WRITTEN">
  <ShortDescription>Objet non sérialisable écrit dans un ObjectOutput</ShortDescription>
  <LongDescription>L'objet non sérialisable {3} est écrit dans ObjectOutput dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code semble transmettre un objet non sérialisable à la méthode <code>ObjectOutput.writeObject</code>. Une erreur se produira si cet objet est effectivement non sérialisable.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="VA_PRIMITIVE_ARRAY_PASSED_TO_OBJECT_VARARG">
  <ShortDescription>Tableau de primitives passé à une fonction attendant un nombre variable d'objets en argument</ShortDescription>
  <LongDescription>Tableau de primitives passé à {2} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code envoie un tableau de primitives à une fonction qui attend un nombre variable d'objets en arguments. Ceci créé un tableau de longueur 1 pour contenir le tableau de primitives puis le passe à la fonction.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_BAD_CAST_TO_ABSTRACT_COLLECTION">
  <ShortDescription>Transtypage douteux d'un type Collection vers une classe abstraite</ShortDescription>
  <LongDescription>Transtypage douteux d'un type Collection vers une classe abstraite {4} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code transtype un object de type <code>Collection</code> vers un type de collection abstrait (tel que <code>Collection</code>). Assurez vous que l'objet est bien du type précisé. Si vous désirez par exemple faire une itération sur une collection, le transtypage vers <code>Set</code> ou <code>List</code> est inutile.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_IMPOSSIBLE_CAST">
  <ShortDescription>Transtypage impossible</ShortDescription>
  <LongDescription>Transtypage impossible de {3} vers {4} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce trantypage lancera toujours une exception <code>ClassCastException</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_NULL_INSTANCEOF" deprecated="true">
  <ShortDescription>Une valeur connue pour être à null est vérifiée pour savoir si elle est une instance d'un type</ShortDescription>
  <LongDescription>Une valeur connue pour être à null est vérifiée pour savoir si elle est une instance d'un type dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce test <code>instanceof</code> renverra systématiquement <code>false</code>, puisqu'il est garanti que la valeur testée sera à <code>null</code>. Bien que ce test soit sûr, il est probable qu'il indique une incompréhension ou une erreur de logique.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_IMPOSSIBLE_INSTANCEOF">
  <ShortDescription>instanceof renverra toujours faux</ShortDescription>
  <LongDescription>instanceof renvoyant toujours faux dans {1}, puisque qu'aucun  {3} ne peut être un {4}</LongDescription>
  <Details>
<![CDATA[
<p>Ce test <code>instanceof</code> renverra toujours faux. Même s'il est sûr, assurez-vous qu'il ne s'agisse pas d'une erreur logique ou d'une mauvaise compréhension.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_VACUOUS_INSTANCEOF">
  <ShortDescription>instanceof renverra toujours vrai</ShortDescription>
  <LongDescription>instanceof renverra toujours vrai dans {1}, puisque chaque {3} est une instance de {4}</LongDescription>
  <Details>
<![CDATA[
<p>Ce test <code>instanceof</code> renverra toujours vrai. Même s'il est sûr, assurez-vous qu'il ne s'agit pas d'une erreur logique ou d'une mauvaise compréhension.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_UNCONFIRMED_CAST">
  <ShortDescription>Transtypage non vérifié/non confirmé</ShortDescription>
  <LongDescription>Transtypage non vérifié/non confirmé de {3} vers {4} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>La faisablité du transtypage n'est pas vérifiée, et tous les objets candidats au transtypage ne sont pas légitimes. Assurez vous que la logique du programme est correcte et que le transtypage n'échouera pas.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="BC_BAD_CAST_TO_CONCRETE_COLLECTION">
  <ShortDescription>Transtypage douteux vers une collection concrète</ShortDescription>
  <LongDescription>Transtypage douteux de {3} vers une collection concrète {4} dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code transtype une collection abstraite (telles que <code>Collection</code>, <code>List</code>, ou <code>Set</code>) vers une implémentation concrète spécifique (telles que <code>ArrayList</code> ou <code>HashSet</code>). Ceci n'est pas forcément correct, et peut rendre votre code plus fragile, puisqu'il un éventuel refactoring futur avec une autre implémentation concrète plus difficile. A défaut d'une raison valable, l'utilisation des classes abstraites est recommandée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RE_POSSIBLE_UNINTENDED_PATTERN">
  <ShortDescription>"." utilisé dans une expression régulière</ShortDescription>
  <LongDescription>"." est utilisé dans une expression régulier dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Une fonction <code>String</code> attendant une expression régulière reçoit "." en paramètre. Est-ce voulu ? Par exemple, <code>s.replaceAll(".", "/")</code> renverra une chaine dont <b>chaque</b> caractère aura été remplacé par le caractère '/'.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="RE_BAD_SYNTAX_FOR_REGULAR_EXPRESSION">
  <ShortDescription>Syntaxe d'expression régulière invalide</ShortDescription>
  <LongDescription>Syntaxe d'expression régulière invalide {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code utilise une expression régulière qui est invalide selon la syntaxe des expressions régulières. Lors de l'exécution, une exception <code>PatternSyntaxException</code> sera lancée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DLS_OVERWRITTEN_INCREMENT">
  <ShortDescription>Incrémentation annulée</ShortDescription>
  <LongDescription>Incrémentation annulée {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code incrémente une valeur (ex., <code>i++</code>) et en annule immédiatement l'effet. Par exemple, <code>i = i++</code> réécrit de façon immédiate la valeur incrémentée avec la valeur originale.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ICAST_QUESTIONABLE_UNSIGNED_RIGHT_SHIFT">
  <ShortDescription>Décalage à droite non signé et transtypage short/byte</ShortDescription>
  <LongDescription>Décalage à droite non signé et transtypage vers un short/byte dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code effectue un décalage à droite non signé, dont le résultat est transtypé vers un <code>short</code> ou un <code>byte</code>, ce qui élimine les bits supérieurs du résultat. Puisque les bits supérieurs sont éliminés, il peut ne pas y avoir de différence entre un décalage à droite signé ou non signé (ceci dépend de la taille du décalage)</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="ICAST_BAD_SHIFT_AMOUNT">
  <ShortDescription>Décalage d'un int hors de proportion (0..31)</ShortDescription>
  <LongDescription>Décalage d'un int hors de proportion ({2}) dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Un décalage de n bits est effectué avec n hors des limites (0..31). Ceci résulte en l'utilisation des 5 bits inférieurs de l'entier pour décider de la valeur du décalage. Ce n'est sans doute pas l'effet recherché et est pour le moins source de confusion.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IM_MULTIPLYING_RESULT_OF_IREM">
  <ShortDescription>Multiplication d'un entier avec le résulat entier d'un modulo</ShortDescription>
  <LongDescription>Multiplication d'un entier avec le résulat entier d'un modulo dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code mutilplie le résultat d'un modulo avec une constante entière. Faîtes attention à la précédence des opérateurs. Par exemple, <code>i % 60 * 1000</code> correspond à <code>(i % 60) * 1000</code>, non à <code>i % (60 * 1000)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_INVOKING_TOSTRING_ON_ARRAY">
  <ShortDescription>Invocation de toString sur un tableau</ShortDescription>
  <LongDescription>Invocation de toString sur un tableau dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code invoque <code>toString</code> sur un tableau, ce qui va générer un résultat assez inutile du genre <code>[C@16f0472</code>. Envisagez d'utiliser <code>String.valueOf</code> pour convertir un tableau en une chaine lisible contenant les valeurs du tableau. Cf Programming Puzzlers, chapitre 3, problème 12.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IM_AVERAGE_COMPUTATION_COULD_OVERFLOW">
  <ShortDescription>Possibilité de débordement du calcul d'une moyenne</ShortDescription>
  <LongDescription>Le calcul d'une moyenne peut déborder dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code calcule la moyenne de deux entiers au moyen d'une division ou d'un décalage signé vers la droite, puis utilise le résultat comme indice d'un tableau. Si les valeurs moyennées sont très grandes, le calcul peut déborder (résultant en un très grand négatif). En supposant que le résultat doive toujours être positif, vous devriez plutôt utiliser un décalage à droite non signé. En d'autres termes, utilisez plutôt  <code>(low+high) &gt;&gt;&gt; 1</code> au lieu de <code>(low+high)/2</code>.</p>
<p>Le bug existe dans de nombreuses implémentations des recherches binaires et des tris fusion. Martin Buchholz <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6412541"> l'a recherché et corrigé </a> dans les librairies du JDK et Joshua Bloch <a href="http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html"> a largement publié ce modèle de bug</a>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IM_BAD_CHECK_FOR_ODD">
  <ShortDescription>Test d'impaire ne fonctionnant pas avec les négatifs</ShortDescription>
  <LongDescription>Un test d'impaire ne fonctionnera pas avec les négatifs dans {1}</LongDescription>
  <Details>
<![CDATA[
<p>Le code utilise <code>x % 2 == 1</code> pour véifier si une valeur est impaire, mais cela ne fonctionera pas avec une valeur négative (Ex. : <code>(-5) % 2 == -1</code>). Si ce code doit tester si une valeur est impaire, envisagez d'utiliser <code>x & 1 == 1</code> ou <code>x % 2 != 0</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_HARDCODED_ABSOLUTE_FILENAME">
  <ShortDescription>Chemin absolu codé en dur dans le code</ShortDescription>
  <LongDescription>Chemin de fichier codé en dur dans le code de {1}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code construit un objet <code>File</code> en utilisant un chemin absolu de fichier codé en dur (Ex. : <code>new File("/home/dannyc/workspace/j2ee/src/share/com/sun/enterprise/deployment");)</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_BAD_MONTH">
  <ShortDescription>Valeur constante pour un mois en dehors de l'intervalle attendu de 0 à 11</ShortDescription>
  <LongDescription>{1} envoi une value de mois erronée de {2} à {3}</LongDescription>
  <Details>
<![CDATA[
<p>Ce code passe une constante mois en dehors de l'intervalle de 0 à 11.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_USELESS_SUBSTRING">
  <ShortDescription>Appel de substring(0) qui retourne la valeur originale</ShortDescription>
  <LongDescription>{1} appelle substring(0), qui renvoit la valeur initiale</LongDescription>
  <Details>
<![CDATA[
<p>Ce code appelle <code>substring(0)</code> sur une chaine, ce qui renvoit la valeur originale.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DMI_CALLING_NEXT_FROM_HASNEXT">
  <ShortDescription>Méthode hasNext() appelant next()</ShortDescription>
  <LongDescription>{1} appelle {3}</LongDescription>
  <Details>
<![CDATA[
<p>La méthode <code>hasNext()</code> appelle la méthode <code>next()</code>. C'est très probablement faux puisque la méthode <code>hasNext()</code> n'est pas changer l'état de l'itérateur tandis que la méthode <code>next()</code> doit changer cet état.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="SWL_SLEEP_WITH_LOCK_HELD">
  <ShortDescription>Appel de la méthode Thread.sleep() avec un verrou</ShortDescription>
  <LongDescription>{1} appelle Thread.sleep() en tenant un verrou</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode appelle <code>Thread.sleep()</code> en tenant un verrou. Ceci peut résulter en de faibles performances, peu de capacité à monter en charge ou un inter-blocage puisque d'autres processus pourraient être en attente du verrou. C'est une meilleure idée d'appeler <code>wait()</code> sur le verrou, afin de le libérer et de permettre à d'autre processus de tourner.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DB_DUPLICATE_BRANCHES">
  <ShortDescription>Méthode utilsant le même code pour deux branches</ShortDescription>
  <LongDescription>La méthode {1} utilise le même code pour deux branches</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode utilise le même code pour implémenter deux branches d'une condition. Vérifiez pour vous assurer que ce n'est pas une erreur de codage.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="DB_DUPLICATE_SWITCH_CLAUSES">
  <ShortDescription>Méthode utilisant le même code pour deux clauses switch</ShortDescription>
  <LongDescription>La méthode {1} utilise le même code pour deux clauses switch</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode utilise le même code pour implémenter deux cas différents d'un <code>switch</code>. Ce peut être normal mais il vaut mieux vérifier que ce n'est pas une erreur de codage.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="IMA_INEFFICIENT_MEMBER_ACCESS">
  <ShortDescription>Accès à un membre privé de la classe englobante</ShortDescription>
  <LongDescription>La méthode {1} accède à un membre privé modifiable de la classe englobante</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode de classe interne lit ou écrit dans un membre privé de sa classe englobante, ou appelle une méthode privée de cette classe englobante. Le compilateur doit générer dans ce cas une méthode spéciale pour accèder à ce membre privé, ce qui rend l'accès moins efficace. Dégrader la protection du membre ou de la méthode permettrait au compilateur de traiter normalement cet accès.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="XFB_XML_FACTORY_BYPASS">
  <ShortDescription>Méthode instanciant directement une implémentation spécifique des interfaces XML</ShortDescription>
  <LongDescription>La méthode {1} instancie directement une implémentation spécifique des interfaces XML</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode instancie une implémentation spécifique de l'interface XML. Il est préférable d'utiliser les classes 'Factory' fournies pour créer ces objets, ce qui permet de changer d'implémentation à l'exécution. Pour des détails, cf. :</p>
<p>
<ul>
 <li>javax.xml.parsers.DocumentBuilderFactory</li>
 <li>javax.xml.parsers.SAXParserFactory</li>
 <li>javax.xml.transform.TransformerFactory</li>
 <li>org.w3c.dom.Document.create<i>XXXX</i></li>
</ul>
</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="USM_USELESS_SUBCLASS_METHOD">
  <ShortDescription>Méthode délégant de manière superflue à une méthode mère</ShortDescription>
  <LongDescription>La méthode {1} délègue de façon superflue à sa méthode mère</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode dérivée se limite à transmettre l'appel à sa méthode mère sans modifier les paramètres reçus. Cette méthode peut être supprimée car elle n'apporte aucune valeur ajoutée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="USM_USELESS_ABSTRACT_METHOD">
  <ShortDescription>Méthode abstraite {1} déjà définie dans l'interface implémentée</ShortDescription>
  <LongDescription>La méthode abstraite {1} est déjà définie dans l'interface implémentée</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode abstraite est déjà définie dans une interface qui est implémentée par cette classe abstraite. Cette méthode peut être supprimée puisqu'elle n'apporte aucune valeur ajoutée.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="CI_CONFUSED_INHERITANCE">
  <ShortDescription>Classe finale déclarant un champ protégé</ShortDescription>
  <LongDescription>La classe {0} est finale mais déclare le champ protégé {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe est déclarée <code>final</code> mais comporte des champs <code>protected</code>. Cette classe étant finale, elle ne pourra jamais être dérivée et donc l'utilisation de <code>protected</code> est troublante. Le modificateur d'accès devrait être modifié à <code>private</code> ou <code>public</code> pour mettre en évidence la véritable utilisation du champ.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="QBA_QUESTIONABLE_BOOLEAN_ASSIGNMENT">
  <ShortDescription>Méthode assignant une valeur boléenne fixe dans une expression booléenne</ShortDescription>
  <LongDescription>La méthode {1} assigne une valeur booléenne fixe dans une expression booléenne</LongDescription>
  <Details>
<![CDATA[
<p>Cette méthode assigne une valeur booléenne fixe (<code>true</code> ou <code>false</code>) à une variable booléenne dans une expression <code>if</code> ou <code>while</code>. Il est probable que le but était d'effectuer une comparaison booléenne utilisant <code>==</code> et non pas une affectation avec <code>=</code>.</p>
]]>
  </Details>
 </BugPattern>
 <BugPattern type="VR_UNRESOLVABLE_REFERENCE">
  <ShortDescription>Classe faisant une référence à une classe ou méthode non résolue</ShortDescription>
  <LongDescription>Référence non résolue de  {0} vers {1}</LongDescription>
  <Details>
<![CDATA[
<p>Cette classe fait une référence à une classe ou une méthode qui ne peut pas être résolue dans l'ensemble des librairies qui ont été analysées en même temps.</p>
]]>
  </Details>
 </BugPattern>
 <BugCode abbrev="IL">Boucle infinie</BugCode>
 <BugCode abbrev="VO">Utilisation de volatile</BugCode>
 <BugCode abbrev="UI">Héritage non sûr</BugCode>
 <BugCode abbrev="FL">Utilisation de simple précision</BugCode>
 <BugCode abbrev="TEST">Test de détecteur incomplet ou prototype</BugCode>
 <BugCode abbrev="IMSE">Interception inutile de IllegalMonitorStateException</BugCode>
 <BugCode abbrev="CN">Mauvaise implémentation de l'idiome Cloneable</BugCode>
 <BugCode abbrev="FI">Utilisations erronées des finaliseurs</BugCode>
 <BugCode abbrev="ES">Vérification de l'égalité de String au moyen de == ou !=</BugCode>
 <BugCode abbrev="ML">Synchronisation sur un champ mis à jour (Verrou modifiable)</BugCode>
 <BugCode abbrev="UG">Méthode get non synchronisée, méthode set synchronisée</BugCode>
 <BugCode abbrev="IC">Initialisation circulaire</BugCode>
 <BugCode abbrev="SI">Initialisation statique suspecte</BugCode>
 <BugCode abbrev="IS">Synchronisation incohérente</BugCode>
 <BugCode abbrev="Eq">Méthodes equals() covariantes</BugCode>
 <BugCode abbrev="Co">Méthodes compareTo() covariantes</BugCode>
 <BugCode abbrev="HE">Les objets égaux doivent avoir des codes de hachage égaux</BugCode>
 <BugCode abbrev="AM">Mauvaise utilisation de l'API</BugCode>
 <BugCode abbrev="Dm">Utilisation d'une méthode inutile</BugCode>
 <BugCode abbrev="UR">Lecture d'un champ non initialisé dans un constructeur</BugCode>
 <BugCode abbrev="RR">Méthode ignorant la valeur de retour de InputStream.read()</BugCode>
 <BugCode abbrev="NN">Méthode contenant un appel isolé à notify()</BugCode>
 <BugCode abbrev="UW">wait() inconditionnel dans une méthode</BugCode>
 <BugCode abbrev="SP">Méthode bouclant sur un champ</BugCode>
 <BugCode abbrev="DC">Possible double vérification d'un champ</BugCode>
 <BugCode abbrev="Wa">Méthode contenant un wait() sans boucle</BugCode>
 <BugCode abbrev="No">Utilisation de notify() au lieu de notifyAll() dans une méthode</BugCode>
 <BugCode abbrev="DE">Exception ignorée</BugCode>
 <BugCode abbrev="Ru">Méthode invoquant run()</BugCode>
 <BugCode abbrev="It">Définition incorrecte d'un itérateur</BugCode>
 <BugCode abbrev="SnVI">Classe Serializable sans versionID</BugCode>
 <BugCode abbrev="Se">Définition incorrecte d'une classe Serializable</BugCode>
 <BugCode abbrev="WS">Seule la méthode writeObject() de la classe est synchronisée</BugCode>
 <BugCode abbrev="RS">La méthode readObject() de la classe est synchronisée</BugCode>
 <BugCode abbrev="SC">Constructeur invoquant Thread.start()</BugCode>
 <BugCode abbrev="MS">Champ statique modifiable</BugCode>
 <BugCode abbrev="EI">Méthode renvoyant un tableau, ce qui peut exposer sa représentation interne</BugCode>
 <BugCode abbrev="Nm">Noms de méthodes ambigus</BugCode>
 <BugCode abbrev="SS">Champ non lu qui devrait être statique ?</BugCode>
 <BugCode abbrev="UuF">Champ inutilisé</BugCode>
 <BugCode abbrev="UrF">Champ non lu</BugCode>
 <BugCode abbrev="UwF">Champ jamais alimenté</BugCode>
 <BugCode abbrev="SIC">Classe interne pouvant être rendue statique</BugCode>
 <BugCode abbrev="TLW">wait() avec deux verrous en attente</BugCode>
 <BugCode abbrev="RV">Valeur de retour d'une méthode mal utilisée</BugCode>
 <BugCode abbrev="IA">Appel ambiguë</BugCode>
 <BugCode abbrev="NP">Déréférencement d'un pointeur à null</BugCode>
 <BugCode abbrev="OS">Flux pas toujours fermé dans les différents chemins d'éxécution</BugCode>
 <BugCode abbrev="PZLA">Renvoyer un tableau de longueur nulle plutôt que la valeur null</BugCode>
 <BugCode abbrev="UCF">Contrôle de flux d'éxécution inutile</BugCode>
 <BugCode abbrev="RCN">Comparaison à null redondante</BugCode>
 <BugCode abbrev="UL">Verrou pas toujours relaché dans les différents chemins d'éxécution</BugCode>
 <BugCode abbrev="RC">Comparaison par référence suspecte</BugCode>
 <BugCode abbrev="EC">Comparaison par equals() suspecte</BugCode>
 <BugCode abbrev="MWN">wait() ou notify() non appareillés</BugCode>
 <BugCode abbrev="SA">Auto-assignation inutile</BugCode>
 <BugCode abbrev="INT">Expression entière suspecte</BugCode>
 <BugCode abbrev="BIT">Expression logique binaire suspecte</BugCode>
 <BugCode abbrev="LI">Initialisation paresseuse non synchronisée</BugCode>
 <BugCode abbrev="JLM">Synchronisation sur un verrou JSR166</BugCode>
 <BugCode abbrev="UPM">Méthode privée jamais invoquée</BugCode>
 <BugCode abbrev="UMAC">Méthode inaccessible dans une classe anonyme</BugCode>
 <BugCode abbrev="EI2">Stockage d'une référence vers un objet modifiable</BugCode>
 <BugCode abbrev="NS">Utilisation suspecte d'un opérateur binaire</BugCode>
 <BugCode abbrev="ODR">Ressource de base données pas toujours fermée dans tous les chemins d'éxécution</BugCode>
 <BugCode abbrev="SBSC">Concaténation de chaînes au moyen de + dans une boucle</BugCode>
 <BugCode abbrev="ITA">Utilisation inefficace de collection.toArray(new Foo[0])</BugCode>
 <BugCode abbrev="SW">Règles de codage de Swing</BugCode>
 <BugCode abbrev="IJU">Jeu d'essai JUnit incorrectement implémenté</BugCode>
 <BugCode abbrev="BOA">Erreur dans la surcharge d'un Adapter</BugCode>
 <BugCode abbrev="SF">switch dont un cas déborde</BugCode>
 <BugCode abbrev="SIO">Opérateur instanceof superflu</BugCode>
 <BugCode abbrev="BAC">Constructeur d'Applet erroné</BugCode>
 <BugCode abbrev="UOE">Utiliser Object.equals()</BugCode>
 <BugCode abbrev="STI">Interruption de thread douteuse</BugCode>
 <BugCode abbrev="DLS">Alimentation à perte</BugCode>
 <BugCode abbrev="IP">Paramètre ignoré</BugCode>
 <BugCode abbrev="MF">Champ masqué</BugCode>
 <BugCode abbrev="WMI">Itérateur Map erroné</BugCode>
 <BugCode abbrev="ISC">Classe statique instanciée</BugCode>
 <BugCode abbrev="REC">Capture de RuntimeException</BugCode>
 <BugCode abbrev="FE">Test d'égalité en virgule flottante</BugCode>
 <BugCode abbrev="UM">Calculs inutiles sur des constantes</BugCode>
 <BugCode abbrev="CD">Dépendance circulaire</BugCode>
 <BugCode abbrev="RI">Interfaces redondantes</BugCode>
 <BugCode abbrev="MTIA">Accès à une instance depuis plusieurs tâches</BugCode>
 <BugCode abbrev="PS">Sémaphores publiques</BugCode>
 <BugCode abbrev="ICAST">Transtypage de valeurs entières</BugCode>
 <BugCode abbrev="RE">Expressions régulières</BugCode>
 <BugCode abbrev="SQL">Injection SQL</BugCode>
 <BugCode abbrev="BRSA">Mauvais accès à un ResultSet</BugCode>
 <BugCode abbrev="ESync">Blocs synchronisés vides</BugCode>
 <BugCode abbrev="QF">Boucles for douteuses</BugCode>
 <BugCode abbrev="VA">Problèmes sur les arguments variables (Java 5)</BugCode>
 <BugCode abbrev="BC">Mauvais transtypages de références</BugCode>
 <BugCode abbrev="IM">Opération douteuse sur des entiers</BugCode>
 <BugCode abbrev="ST">Mauvaise utilisation de champs statiques</BugCode>
 <BugCode abbrev="JCIP">Violation d'une annotation net.jcip.annotations</BugCode>
 <BugCode abbrev="DMI">Invocation inutile d'une méthode</BugCode>
 <BugCode abbrev="PZ">Détection de bogue inspirée par "Programming Puzzlers" de Josh Bloch et Neal Gafter</BugCode>
 <BugCode abbrev="SWL">Sleep avec un verrou maintenu</BugCode>
 <BugCode abbrev="J2EE">Erreur J2EE</BugCode>
 <BugCode abbrev="DB">Branches dupliquées</BugCode>
 <BugCode abbrev="IMA">Accès inefficace à un membre</BugCode>
 <BugCode abbrev="XFB">Court-circuit de la fabrique XML</BugCode>
 <BugCode abbrev="USM">Méthode surchargée inutilement</BugCode>
 <BugCode abbrev="CI">Héritage confu</BugCode>
 <BugCode abbrev="QBA">Assignation booléenne douteuse</BugCode>
 <BugCode abbrev="VR">Problème de compatibilité entre les versions</BugCode>
 <BugCode abbrev="DP">Utiliser doPrivileged</BugCode>
</MessageCollection>