Valeurs, promotions, texte et contrôle de flux

Comprendre le mécanisme

Java détermine les types à la compilation. var infère un type local ; il ne rend pas la variable dynamiquement typée. Les opérations sur byte et short peuvent promouvoir les opérandes en int. Un cast explicite peut perdre de l’information. Pour des objets, == compare généralement les références ; equals porte le contrat d’égalité de la classe. String est immuable alors que StringBuilder accumule des modifications.

Raisonner et vérifier

Tracez séparément la sélection d’une branche et la valeur calculée. Un switch expression doit fournir un résultat sur chaque chemin possible ; yield fournit la valeur d’un bloc. Un wrapper null peut provoquer une NullPointerException à l’unboxing. Les tests doivent inclure bornes numériques, chaîne vide, null et chemin par défaut, pas seulement un exemple nominal.

Deux familles de valeurs

Les primitifs représentent directement des valeurs comme un entier ou un booléen ; les références désignent des objets ou null. Un Integer et un int ne se comportent donc pas identiquement face à l’absence. Avant une opération, repérez la famille de chaque opérande et les conversions possibles. Cette lecture évite d’attribuer à une valeur nullable les garanties d’un primitif simplement parce que leurs noms se ressemblent.

Inférer sans rendre dynamique

var laisse le compilateur déterminer le type d’une variable locale à partir de son initialisation. Une fois établi, ce type ne change pas à chaque affectation. Si le résultat initial est un entier, lui affecter ensuite une chaîne ne devient pas valide grâce au mot-clé. Utilisez l’inférence lorsque le type demeure lisible et vérifiez séparément le type de l’expression initiale, notamment après une promotion numérique.

Affecter avant de consulter

Une variable locale doit être définitivement assignée sur le chemin où elle est lue. Les valeurs initiales prévues pour certains champs ne doivent pas être généralisées aux locales. Tracez les branches : si une condition laisse la variable sans affectation, la lecture n’a pas de contrat sûr. Ajouter un zéro arbitraire peut faire compiler le code mais masquer l’absence d’une décision métier nécessaire.

Le déballage exige une valeur présente

Une opération sur un wrapper peut demander son unboxing vers un primitif. Si la référence vaut null, cette conversion peut lancer une NullPointerException avant le calcul attendu. Définissez si l’absence est une erreur ou un état normal, puis placez une garde adaptée. Un test avec une référence non nulle ne couvre pas ce chemin, même si toutes les valeurs numériques nominales ont été essayées.

Promotion et division entière

Les opérations sur des types numériques étroits peuvent promouvoir les opérandes, par exemple byte plus byte vers int. Avec deux int, une division entière ne conserve pas la fraction : cinq divisé par deux produit deux. var infère le type de ce résultat, sans changer l’opération réalisée. Pour une division décimale, choisissez explicitement une représentation compatible avec la précision attendue et vérifiez les règles d’arrondi utiles.

Conversions et perte de précision

Un cast peut réduire une plage ou une précision ; il ne prouve pas que la valeur initiale était admissible. Avant de convertir une donnée d’API, vérifiez son format et les bornes du type cible. Pour un identifiant qui doit garder tous ses chiffres sans calcul, une représentation textuelle peut être plus appropriée qu’un nombre approximatif. La conversion doit être une étape du contrat, pas une réparation aveugle d’entrée invalide.

Identité, contenu et texte mutable

Pour des références, == répond à une question d’identité, tandis que equals applique le contrat de la classe. Deux chaînes de même contenu ne doivent pas être comparées par une hypothèse générale sur leur partage en mémoire. String est immuable ; StringBuilder offre des opérations de modification de son contenu. Distinguez donc égalité de texte, identité d’objet et mutabilité avant de déduire ce qu’une affectation ou concaténation préserve.

Suivre tous les chemins du switch

Un switch doit respecter le type du sélecteur et les règles des cas de la version ciblée. Une expression switch doit fournir une valeur selon son contrat ; un bloc de branche peut utiliser yield pour la produire. Listez les états attendus et la politique pour une entrée inconnue ou null. Le nom d’un état reçu du réseau n’est pas encore une valeur validée de votre modèle.

Le type ne définit pas le domaine

Un int représente une plage de valeurs machine, pas une quantité positive ou un âge autorisé. Après reconnaissance du type et conversion contrôlée, appliquez les bornes et relations du domaine. Un zéro peut être une valeur métier distincte d’une absence. Les tests doivent donc séparer ces catégories, puis vérifier que chaque refus intervient avant une mutation ou un appel externe.

Respecter l’ordre et les effets

Une expression peut consulter et modifier plusieurs états. La réordonner pour la rendre plus compacte peut changer les valeurs observées, même si les opérateurs semblent arithmétiques. Décomposez les étapes lorsque des effets se combinent et notez l’état après chaque affectation. Cette méthode sert aussi à analyser un QCM : distinguez l’ordre d’évaluation, le type obtenu et la valeur calculée au lieu de deviner à partir de l’affichage.

Atelier guidé : lire, expliquer et vérifier le code

class Main {
    public static void main(String[] args) {
        var result = 5 / 2;
        System.out.print(result);
    }
}

Le compilateur voit deux littéraux entiers dans la division. L’opération produit donc un entier dont la partie fractionnaire est écartée selon les règles de division entière. La variable déclarée avec var reçoit ce type inféré et le programme affiche 2. L’inférence ne transforme pas rétrospectivement la division en calcul flottant.

Modifiez un opérande pour obtenir une division avec un type décimal, puis comparez le type et l’affichage. Reprenez ensuite l’addition de deux byte et vérifiez que le type de l’expression est int. Enfin, essayez une réaffectation textuelle à result dans un fichier de laboratoire : le refus de compilation démontre que var n’est pas un mécanisme de typage dynamique.