Premiers programmes Java

Un premier programme Java donne à l’ordinateur une courte liste d’instructions. La classe qui les contient et la méthode main indiquent à Java où placer ces instructions et où commence l’exécution.

Place les instructions dans main

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Les accolades extérieures délimitent le corps de la classe. Les accolades intérieures délimitent le corps de la méthode. Au démarrage de ce programme, Java exécute la première instruction à l’intérieur de main. Les autres instructions placées en dessous s’exécutent de haut en bas. Lorsque main s’achève, ce petit programme se termine.

Recopie soigneusement public static void main(String[] args). Ici, public permet au lanceur d’appeler la méthode, static permet son exécution sans créer d’objet au préalable et void indique que la méthode ne renvoie aucun résultat. String[] args reçoit les mots saisis sur la ligne de commande après le nom du programme. Tu peux afficher un message sans utiliser ces mots.

Fais correspondre la ponctuation et les noms

Une instruction comme System.out.println("Hi"); se termine par un point-virgule. Une accolade ouvrante { a besoin d’une accolade fermante }. Les en-têtes de classe et de méthode ci-dessus ouvrent des blocs ; ne remplace pas ces accolades ouvrantes par des points-virgules. Indenter l’instruction de quatre espaces supplémentaires par rapport à l’en-tête de sa méthode rend l’imbrication visible.

Enregistre public class Hello dans Hello.java. Le nom de la classe publique et la partie précédant .java doivent correspondre exactement, majuscules comprises. Si la déclaration indique public class Other, le fichier doit être Other.java. Un message du compilateur indiquant que la classe doit être déclarée dans un autre fichier signale cette absence de correspondance.

Java est sensible à la casse. Le nom System doit commencer par un S majuscule ; system.out.println("Hi"); ne compile pas. Une méthode appelée Main est différente de main. Une classe qui ne contient que Main peut compiler, mais le lanceur ne trouve pas la méthode d’entrée attendue lorsque tu l’exécutes.

Rends le code lisible

Utilise une instruction par ligne et quatre espaces d’indentation pour chaque niveau d’accolades. La plupart des espaces et des retours à la ligne entre les éléments du code n’ont aucun effet sur la compilation. Les espaces à l’intérieur du texte entre guillemets modifient en revanche la sortie. Les noms de classes s’écrivent par convention en PascalCase, comme TravelTime.

Un commentaire explique le code aux personnes qui le lisent. Java ignore tout ce qui suit // sur cette ligne. Un commentaire de bloc commence par /* et se termine par */ ; il peut s’étendre sur plusieurs lignes. Un commentaire utile explique une raison, comme // Convert hours to seconds, à côté d’une conversion dont le but pourrait être obscur.

Reconnais la forme plus courte

Java 25 et les versions ultérieures prennent aussi en charge un fichier source compact :

void main() {
    IO.println("Hello, world!");
}

Cette forme omet la déclaration explicite de classe. IO.println affiche une ligne et IO.readln("Your name: ") affiche une invite et renvoie la ligne saisie. La forme classique avec une classe fonctionne aussi avec les versions antérieures de Java ; les deux formes fournissent une méthode main où l’exécution commence.

Écrire le code source et exécuter un programme sont deux étapes distinctes. Java vérifie et traduit d’abord ton code, puis l’exécute. Savoir quelle étape a échoué t’aide à choisir où chercher.

Compile le code source, puis lance la classe

Le code source est le texte d’un fichier .java. Le compilateur, javac, traduit un code source valide en bytecode dans un fichier .class. La machine virtuelle Java (JVM) exécute ce bytecode. Une JVM adaptée permet d’exécuter le même bytecode sur différents systèmes d’exploitation.

Ouvre un terminal dans le dossier contenant Hello.java et saisis :

javac Hello.java
java Hello

La première commande crée Hello.class lorsque la compilation réussit. La seconde démarre le programme. Son argument est le nom de la classe, sans .class : java Hello.class demande au lanceur de chercher un nom de classe incorrect et échoue.

Le JDK, ou Java Development Kit, fournit les deux commandes. Un environnement de développement intégré, comme IntelliJ IDEA, Eclipse, NetBeans ou Visual Studio Code avec prise en charge de Java, effectue la compilation et le lancement lorsque tu appuies sur le bouton d’exécution. Il peut signaler des erreurs pendant la saisie, mais ce sont toujours des erreurs du même langage Java.

Depuis Java 11, le mode fichier source offre un raccourci pour un petit programme contenu dans un seul fichier :

java Hello.java

Cette commande compile en mémoire et exécute le code source sans laisser de fichier .class. Distingue les deux formes : java Hello lance une classe compilée, tandis que java Hello.java lance le code source.

Lis les erreurs de compilation

Une erreur de compilation empêche la compilation de réussir. Par exemple, un point-virgule manquant peut produire :

Hello.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^

Le message indique le fichier, la ligne et l’endroit où le compilateur a remarqué le problème. La véritable erreur peut se trouver avant : un guillemet non fermé sur une ligne peut perturber les lignes suivantes. Lis la ligne indiquée et celle qui la précède. Corrige la première erreur signalée et recompile avant de modifier plusieurs autres lignes. Une seule correction peut faire disparaître de nombreux messages ultérieurs.

Distingue les erreurs d’exécution des résultats incorrects

Si une variable entière divisor contient zéro, 5 / divisor échoue pendant l’exécution avec ArithmeticException: / by zero. L’instruction arithmétique peut être un code source valide même si ses valeurs à l’exécution la font échouer.

Un programme qui affiche une moyenne de 8 alors que la valeur correcte est d’environ 8,33 comporte une erreur de logique. Aucun message du compilateur ne peut t’indiquer que ce résultat est incorrect pour ta tâche. Teste le programme avec des entrées connues, examine les valeurs intermédiaires et trouve le premier calcul incorrect.

Travaille selon un cycle court : modifier, enregistrer, compiler, exécuter, tester. L’enregistrement compte : la compilation lit le fichier enregistré, donc les modifications non enregistrées ne peuvent pas changer le programme compilé.

L’affichage est le premier moyen de voir ce que fait un programme. Java te permet de contrôler les caractères affichés et l’endroit où commence la ligne suivante.

Suis la position d’affichage

System.out.print(...) écrit sa valeur et laisse la position d’affichage sur la même ligne. System.out.println(...) écrit sa valeur, puis commence une nouvelle ligne. Appeler System.out.println() avec des parenthèses vides ajoute simplement un retour à la ligne.

System.out.print("Hello");
System.out.print(", ");
System.out.println("world");
System.out.println("Bye");

Les deux premiers appels laissent la position après l’espace qui suit la virgule. Le troisième ajoute world à cet endroit, puis passe à une nouvelle ligne. La sortie exacte est :

Hello, world
Bye

Java n’insère aucune espace entre les appels. Si tu supprimes l’espace dans ", ", la première ligne devient « Hello,world ». Un println() vide entre les deux dernières instructions créerait une ligne vide entre les messages.

Choisis entre du texte et une valeur

Un littéral de chaîne de caractères est un texte placé entre guillemets doubles. Afficher "7 * 6" montre le texte « 7 * 6 ». Afficher 7 * 6 évalue la multiplication et montre « 42 ». Les guillemets font partie de la ponctuation du code ; ils ne sont pas affichés avec le littéral.

De même, si name contient « Ada », System.out.println(name); affiche « Ada », tandis que System.out.println("name"); affiche « name ». Utilise la variable sans guillemets lorsque tu veux obtenir la valeur qu’elle contient.

Les guillemets simples ont un autre rôle. 'A' est une valeur char correspondant à un caractère. 'Hello' ne peut pas contenir un message de plusieurs caractères et provoque une erreur de compilation. Utilise "Hello" pour ce texte.

Place des caractères spéciaux dans une chaîne

Une séquence d’échappement commence par une barre oblique inverse et représente un caractère dans le littéral.

Par exemple :

System.out.println("She said \"hi\"");
System.out.println("C:\\Users");

Ces instructions affichent She said "hi" et C:\Users sur des lignes distinctes. Les barres obliques inverses supplémentaires indiquent à Java comment interpréter le caractère suivant ; elles ne sont pas toutes recopiées dans la sortie.

Un seul appel peut aussi afficher plusieurs lignes :

System.out.println("Name:\tAda\nAge:\t36");

La tabulation sépare l’intitulé de la valeur et \n place l’âge sur la ligne suivante. L’appel à println ajoute aussi son propre retour à la ligne final. Une tabulation déplace la position jusqu’à un taquet de tabulation : sa largeur visible dépend donc de l’environnement d’affichage.

Un littéral de chaîne ordinaire entre guillemets doit s’ouvrir et se fermer sur une seule ligne du code source. Appuyer sur Entrée au milieu laisse un littéral non fermé. Pour répartir un long message sur plusieurs lignes du code source, écris deux littéraux complets reliés par + ou utilise des appels d’affichage distincts.

Une variable donne un nom à une valeur pour que les instructions suivantes puissent l’utiliser. Son type indique à Java quel genre de valeur elle peut contenir ; une affectation modifie la valeur stockée.

Déclare et initialise

int age;
age = 36;

La déclaration introduit age comme un int. L’affectation stocke 36. La forme combinée int age = 36; s’appelle une initialisation. Une variable locale doit recevoir une valeur avant que tu la lises. Déclarer int age; puis afficher immédiatement age produit une erreur indiquant que la variable pourrait ne pas avoir été initialisée.

Déclare un nom une seule fois dans le même corps de méthode. Pour modifier sa valeur plus tard, écris age = 37;, sans répéter int. Un second int age = 37; dans ce corps tente de déclarer à nouveau la même variable.

Lis l’affectation de droite à gauche

Le membre de droite de = est calculé en premier. Java stocke ensuite ce résultat dans la variable de gauche :

int count = 5;
count = count + 1;

La seconde instruction lit la valeur actuelle 5, lui ajoute 1 et stocke 6. Le signe = signifie affectation ; il n’affirme pas mathématiquement qu’un nombre est égal à lui-même plus un. Le membre de gauche doit désigner un emplacement où stocker la valeur ; 36 = age; est invalide.

Une affectation copie la valeur à cet instant :

int a = 5;
int b = a;
a = 10;

À présent, a contient 10 et b contient 5. Il n’existe aucun lien permanent qui recalcule b lorsque a change.

Suis un échange de valeurs

Supposons que first contient 4 et second contient 9. La suite first = second; second = first; perd le 4 dès la première étape et laisse les deux valeurs à 9. Conserve d’abord la valeur d’origine :

int temp = first;
first = second;
second = temp;

Un tableau de suivi d’exécution indique la valeur de chaque variable après chaque instruction. Pour int x = 3; x = x * 2; x = x + 1;, les valeurs sont 3, puis 6, puis 7. Mets à jour une ligne à la fois en utilisant les dernières valeurs stockées.

Choisis des noms utiles et des types fixes

Les noms peuvent contenir des lettres, des chiffres, des caractères de soulignement et des signes dollar. Ils ne peuvent pas commencer par un chiffre ni être un mot réservé comme class. La casse compte : total et Total sont différents. Utilise des noms descriptifs en camelCase, comme distanceKm ou secondsLeft.

Une variable final ne peut recevoir une affectation qu’une seule fois. final int SECONDS_PER_HOUR = 3600; donne un nom clair à un facteur de conversion fixe. Lui affecter une nouvelle valeur empêche la compilation. Par convention, les noms de constantes utilisent des mots en majuscules séparés par des caractères de soulignement.

Depuis Java 10, var peut déduire le type d’une variable locale à partir de son initialiseur. var count = 10; déduit int ; var price = 2.5; déduit double. Le type déduit reste fixe. var count; échoue, car il n’y a pas d’initialiseur à partir duquel déduire un type.

Le type d’une valeur détermine sa plage de valeurs, l’écriture de ses littéraux et les calculs que Java peut effectuer avec elle. Utilise int pour les dénombrements ordinaires et double pour les mesures ordinaires, tout en sachant reconnaître les autres types primitifs.

Compare les huit types primitifs

Les valeurs finies de float vont approximativement de −3,4 × 10³⁸ à +3,4 × 10³⁸ ; celles de double vont approximativement de −1,8 × 10³⁰⁸ à +1,8 × 10³⁰⁸. Ces vastes plages ne rendent pas exactement représentable chaque nombre décimal qu’elles contiennent.

Un char représente souvent un caractère, comme 'A'. Certains caractères Unicode nécessitent deux unités de code UTF-16 ; un seul char ne peut donc pas représenter tous les caractères possibles. 'A' a pour code numérique 65, 'a' a 97 et '7' a 55. Le caractère '7' est distinct de l’entier 7. Un boolean n’est pas un nombre : boolean active = 1; échoue.

Écris les littéraux selon leur type

Un littéral écrit une valeur directement dans le code source. 42 est un littéral int, 42L un long, 3.5 un double et 3.5f un float. Les littéraux de caractère utilisent des guillemets simples ; les littéraux String utilisent des guillemets doubles. Les noms des types primitifs sont en minuscules, tandis que String commence par une majuscule.

Écris long large = 3000000000L;. Sans le L, ce littéral entier est trop grand. Écris float rate = 3.5f; : 3.5 seul est de type double, que Java ne réduit pas implicitement en float. Une constante entière dont la valeur convient peut initialiser un type entier plus petit : byte b = 100; compile, mais pas byte b = 200;.

Les caractères de soulignement entre les chiffres rendent un littéral lisible : 1_000_000 a la même valeur que 1000000. La notation scientifique utilise e, comme dans 1.5e3, qui signifie 1 500,0. Les nombres décimaux du code source utilisent toujours un point.

Surveille la plage de l’opération

Un calcul entier peut provoquer un dépassement de capacité sans message d’erreur. Ajouter 1 au plus grand int ramène au plus petit int. Le produit 50_000 * 50_000 utilise des calculs int et produit -1794967296. Dans 50_000L * 50_000, un opérande est de type long : le produit est donc le résultat correct 2500000000.

Donner seulement le type long à la variable qui reçoit le résultat intervient trop tard pour corriger un produit int qui a déjà subi un dépassement de capacité. Choisis un opérande de type suffisamment large avant la multiplication.

Les valeurs en virgule flottante présentent une autre limite. Beaucoup de fractions décimales sont stockées sous forme d’approximations binaires : 0.1 + 0.2 affiche 0.30000000000000004. Formate ces résultats pour l’affichage. Les calculs monétaires exacts peuvent stocker des centimes entiers dans un long ; la classe BigDecimal offre une autre possibilité pour les calculs décimaux exacts.

Une String contient du texte, notamment des espaces, des chiffres, de la ponctuation, ou aucun caractère. L’opérateur + peut combiner ce texte avec d’autres valeurs pour construire un message.

Assemble des valeurs en texte

String firstName = "Ada";
String lastName = "Lovelace";
System.out.println(firstName + " " + lastName);

La sortie est « Ada Lovelace ». Le littéral du milieu fournit l’espace. Sans lui, firstName + lastName produirait « AdaLovelace ». La concaténation n’ajoute pas de séparateurs pour toi.

La concaténation consiste à assembler des valeurs dans une nouvelle chaîne. Si l’un des opérandes de + est une String, Java convertit l’autre valeur en texte et les assemble. Ainsi, "Age: " + 36 devient « Age: 36 » et "Price: " + 2.5 devient « Price: 2.5 ». Les chiffres du résultat font désormais partie d’une valeur textuelle.

String commence par un S majuscule. Contrairement aux huit types primitifs, c’est une classe. Écrire string name = "Ada"; avec un s minuscule empêche la compilation. La chaîne vide "" est un texte valide sans caractères ; ce n’est pas une valeur manquante.

Suis les signes plus de gauche à droite

Considère :

System.out.println("Sum: " + 2 + 3);

Le premier + assemble la String et 2, ce qui produit « Sum: 2 ». Le second assemble cette String et 3, ce qui produit « Sum: 23 ». Une fois que le résultat intermédiaire est du texte, le + suivant continue à assembler du texte.

Compare trois formes :

Utilise des parenthèses lorsqu’un message doit contenir le résultat d’une addition ou d’une soustraction. Par exemple, "Diff: " + (5 - 2) donne « Diff: 3 ». Sans les parenthèses, "Diff: " + 5 - 2 tente de soustraire 2 à une String et ne compile pas.

La multiplication et la division sont prioritaires sur +. L’expression "Area: " + 4 * 5 calcule d’abord le produit et donne « Area: 20 ».

Construis un message par étapes

String message = "Hi";
message += "!";

La variable mise à jour contient « Hi! ». Pour une String, += ajoute du texte en affectant à nouveau le résultat de la concaténation à la variable. Tu peux assembler un court message avec plusieurs instructions et l’afficher une seule fois à la fin.

Fais attention aux caractères. Deux opérandes char ne déclenchent pas de concaténation de String. 'A' + 'B' additionne leurs codes numériques, 65 et 66, et produit l’int 131. Commencer par la String vide change la suite : "" + 'A' + 'B' crée d’abord « A », puis « AB ». Les guillemets déterminent les types des opérandes et donc aussi le sens de +.

Une expression combine des valeurs pour produire un résultat. Java l’évalue selon la priorité des opérateurs, puis une instruction peut stocker ou afficher ce résultat.

Écris les opérations explicitement

Les opérateurs arithmétiques sont +, -, *, / et % : addition, soustraction, multiplication, division et reste. Avec int width = 4; et int height = 5;, width * height vaut 20.

Toute multiplication nécessite *. La forme 2(3 + 4), semblable à une écriture algébrique, n’est pas valide en Java ; écris 2 * (3 + 4). Java n’a pas d’opérateur arithmétique de puissance. 2 ^ 3 désigne une opération bit à bit et produit 1, pas 8. Pour élever une valeur au carré, écris x * x ; pour calculer une autre puissance, utilise Math.pow.

Applique les priorités avant de lire de gauche à droite

Au même niveau, ces opérateurs arithmétiques se regroupent de gauche à droite. 2 + 3 * 4 vaut 14 ; (2 + 3) * 4 vaut 20. Dans 10 - 4 - 3, la première soustraction donne 6 et la seconde donne 3. Dans 24 / 4 * 2, la division donne 6 et la multiplication donne 12. Pour traiter 4 * 2 comme dénominateur, il faudrait des parenthèses.

Calcule correctement une moyenne

Supposons int a = 7, b = 8, c = 10;. L’expression a + b + c / 3 ne divise que c. La division entière donne 3 pour 10 / 3, puis les additions donnent 18.

(a + b + c) / 3 regroupe le total entier, 25, mais les deux opérandes de / sont des entiers. Le résultat est 8. Utiliser (a + b + c) / 3.0 conserve la partie fractionnaire et produit 8.333333333333334.

Les types des opérandes déterminent le calcul. Deux opérandes int produisent un résultat int. Un opérande double entraîne la conversion de l’autre opérande numérique en double, comme dans 5 * 2.0, dont le résultat est 10.0. La variable qui reçoit le résultat ne change pas la façon dont le calcul précédent a été effectué.

Mets à jour une valeur stockée

int total = 10;
total += 5;
total *= 2;
total--;

Les valeurs stockées deviennent 10, 15, 30 et 29. Pour ces opérandes int, total += 5; effectue la même mise à jour que total = total + 5;. Les opérateurs -=, /= et %= combinent de la même façon une opération et une affectation. count++; augmente une variable de 1 et count--; la diminue de 1. Utilisées comme instructions distinctes, ces opérations sont faciles à suivre.

Une expression comme a + b ne modifie aucun des deux opérandes. Pour utiliser son résultat, affecte-le ou passe-le à un appel d’affichage : int sum = a + b; ou System.out.println(a + b);. La ligne isolée a + b; ne compile pas, car Java n’autorise pas cette expression arithmétique comme instruction autonome. Les affectations, incrémentations, décrémentations et appels de méthodes peuvent constituer des instructions autonomes et avoir des effets.

La division entière indique combien de groupes complets tiennent dans une quantité. Le reste indique ce qui subsiste. Ensemble, ces opérations permettent de répartir une quantité en parties utiles.

Prévois le quotient et le reste

Lorsque les deux opérandes sont des entiers, / supprime la partie fractionnaire en se rapprochant de zéro. 7 / 2 vaut 3, 2 / 3 vaut 0 et -7 / 2 vaut −3. C’est une troncature, pas un arrondi à l’entier le plus proche.

L’opérateur reste % renvoie ce qui subsiste après la division. 17 / 5 donne 3 et 17 % 5 donne 2. Trois groupes de 5 représentent 15, il reste donc 2. Pour des opérandes entiers et un diviseur non nul, (a / b) * b + a % b reconstitue a avec les calculs entiers de Java.

Le signe d’un reste non nul est celui de l’opérande de gauche : -7 % 3 vaut −1, tandis que 7 % -3 vaut 1. Pour les entiers positifs ou nuls, n % 2 vaut 0 pour les valeurs paires et 1 pour les valeurs impaires.

Décompose des secondes en unités plus grandes

Pars de 3 725 secondes :

int totalSeconds = 3725;
int hours = totalSeconds / 3600;
int secondsAfterHours = totalSeconds % 3600;
int minutes = secondsAfterHours / 60;
int seconds = secondsAfterHours % 60;

La première division donne 1 heure complète. Le reste est de 125 secondes. Diviser ce reste par 60 donne 2 minutes, avec 5 secondes restantes. Le résultat est 1 h 2 min 5 s. En reconstituant le total, on obtient 3 600 secondes plus 120 secondes plus 5 secondes, soit 3 725.

Utilise le reste après retrait des heures pour trouver les minutes dans l’heure en cours. Diviser le total d’origine par 60 donnerait les 62 minutes complètes, y compris celles déjà comptées comme une heure.

Les mêmes opérateurs extraient les chiffres décimaux d’un entier positif ou nul. 4827 % 10 donne le dernier chiffre, 7 ; 4827 / 10 donne les chiffres restants à gauche, 482.

Distingue les groupes complets du nombre de contenants nécessaires

Pour 50 œufs et des boîtes de 12 œufs, 50 / 12 donne 4 boîtes pleines et 50 % 12 donne 2 œufs restants. Il faut une cinquième boîte pour contenir tous les œufs. Pour des effectifs positifs ou nuls et des capacités de boîte strictement positives, l’expression entière (count + size - 1) / size arrondit le nombre de contenants à l’entier supérieur, à condition que l’addition ne provoque pas de dépassement de capacité. Dans cet exemple, (50 + 12 - 1) / 12 donne 5.

Choisis une division avec partie fractionnaire avant de la faire

Une destination double ne peut pas récupérer une partie fractionnaire supprimée. Donne à un opérande le type double avant la division lorsque tu as besoin de la partie fractionnaire.

Une division ou un calcul de reste par le zéro entier lève une ArithmeticException pendant l’exécution. La division en virgule flottante se comporte différemment : 5.0 / 0 donne Infinity, -5.0 / 0 donne -Infinity et 0.0 / 0 donne NaN, qui signifie « pas un nombre ». Un résultat peut donc être inutilisable même lorsque l’exécution ne s’arrête pas.

Les calculs décimaux sont utiles pour les mesures et les moyennes. La classe Math propose des calculs prêts à l’emploi, tandis que l’arrondi permet de choisir comment stocker ou présenter un résultat.

Conserve les fractions et reconnais les approximations

150 / 2.5 donne 60.0, une vitesse en km/h lorsque la distance est de 150 km et la durée de 2,5 heures. Comme un opérande est un double, la division conserve un résultat fractionnaire si nécessaire. Les valeurs ordinaires de type double qui sont entières s’affichent avec une partie décimale, comme 60.0.

Un double stocke une approximation binaire de nombreuses valeurs décimales. Ainsi, 1.1 * 3 affiche 3.3000000000000003 et 10.0 / 3 affiche 3.3333333333333335. Garde la valeur utilisée pour les calculs suivants et arrondis-la au moment de la présenter.

Les valeurs grandes ou petites peuvent s’afficher en notation scientifique. 1.23456789E7 représente 12 345 678,9 et 1.0E-4 représente 0,0001. Pour les valeurs finies positives, la notation ordinaire est utilisée de 0,001 inclus à 10 000 000 exclu. La notation scientifique modifie la forme affichée, pas la valeur sous-jacente.

Appelle des méthodes utiles de Math

Math se trouve dans java.lang : aucune importation n’est donc nécessaire.

Math.sqrt et Math.pow renvoient un double. La constante Math.PI vaut environ 3,141592653589793. Pour un cercle de rayon 2,5 cm, Math.PI * 2.5 * 2.5 donne 19.634954084936208 cm², soit environ 19,63 cm². Pour un triangle rectangle dont les côtés de l’angle droit mesurent 3 cm et 4 cm, Math.sqrt(3 * 3 + 4 * 4) additionne d’abord les carrés de ces côtés pour obtenir 25, puis donne 5.0 cm.

Choisis le sens de l’arrondi

round choisit l’entier le plus proche et, pour une valeur exactement à mi-chemin, arrondit vers l’infini positif. floor arrondit vers l’infini négatif ; ceil arrondit vers l’infini positif. Pour les nombres négatifs, arrondir vers le bas donne une valeur plus négative : ainsi, la partie entière inférieure de −2,7 est −3,0.

Pour un argument double, Math.round renvoie un long. Stocke ce résultat dans un long ou convertis-le explicitement lorsqu’un int convient : int rounded = (int) Math.round(2.7); stocke 3. floor et ceil renvoient des valeurs double.

Pour arrondir une valeur stockée à deux décimales, utilise Math.round(12.3456 * 100) / 100.0, qui donne 12.35. La multiplication amène le chiffre des centièmes au rang des unités. Diviser par 100.0 ramène ensuite la valeur à son échelle avec une division en virgule flottante ; diviser par l’entier 100 supprimerait la fraction et donnerait 12. Si seul le texte affiché doit être arrondi, printf peut formater directement la valeur d’origine.

Java convertit parfois automatiquement une valeur numérique. D’autres conversions nécessitent un transtypage explicite. Un transtypage change le type d’une valeur à un endroit précis d’une expression : sa position influe donc sur le résultat.

Effectue une conversion élargissante automatique

La principale chaîne de conversions numériques élargissantes est byte → short → int → long → float → double. Un char peut aussi être converti par élargissement en int, puis dans les types suivants. Par exemple, double d = 5; stocke 5.0, et toute valeur int tient exactement dans un long.

Une conversion élargissante vers un type en virgule flottante peut entraîner une perte de précision. Les conversions de int vers float, de long vers float et de long vers double peuvent arrondir un grand entier. La conversion d’un int en double est exacte. Par exemple, (float) 16777217 devient 1.6777216E7, qui représente 16 777 216.

Effectue une conversion réductrice par transtypage

Un transtypage consiste à écrire le type cible entre parenthèses avant la valeur :

int n = (int) 3.99;

Le résultat stocké est 3. Sans (int), Java refuse d’affecter le littéral double à un int. La conversion d’un double fini et compris dans la plage du type entier effectue une troncature vers zéro : (int) -3.99 donne aussi −3. La troncature diffère de l’arrondi ; (int) Math.round(3.99) donne 4.

Les conversions réductrices nécessitent généralement un transtypage. Une exception utile permet à une expression constante entière dont la valeur convient d’initialiser un byte, un short ou un char. Ainsi, byte b = 100; est valide sans (byte). Une variable int non constante ne bénéficie pas de cette exception simplement parce que sa valeur actuelle convient.

Place le transtypage avant l’opération qui en a besoin

Soit int sum = 25; et int count = 3;.

Un transtypage est prioritaire sur la multiplication et la division. Les parenthèses déterminent s’il s’applique à un seul opérande ou à un calcul terminé. Un transtypage après une division entière ne peut pas restituer l’information supprimée.

Prévois les changements des caractères et des petits entiers

(int) 'A' donne son code de caractère, 65. Ajouter 1 à 'A' produit l’int 66. Pour reconvertir le résultat complet en caractère, écris (char) ('A' + 1), ce qui donne 'B'. Sans les parenthèses autour de la somme, le transtypage ne s’appliquerait qu’à 'A'.

Une conversion réductrice entre types entiers ne conserve que les bits de poids faible. (byte) 200 devient −56 ; (int) 3_000_000_000L devient −1 294 967 296. Un transtypage autorise la conversion, mais ne vérifie pas que la valeur d’origine tient dans le type.

L’affectation composée comprend une conversion intégrée vers le type de gauche. Avec int x = 10;, x += 2.7; calcule 12,7 et le réduit à 12. L’affectation simple x = x + 2.7; échoue, car son membre de droite est un double.

Un texte peut contenir des chiffres sans être un nombre. Pour calculer avec du texte saisi ou stocké, analyse-le pour le convertir en type numérique. Pour construire un message, reconvertis une valeur numérique en texte.

Analyse le texte avant de calculer

L’expression "42" + 1 produit « 421 ». Comme l’opérande de gauche est une String, + effectue une concaténation. Integer.parseInt("42") + 1 produit 43, car l’analyse fournit un int avant l’addition.

String first = "12";
String second = "30";
int total = Integer.parseInt(first) + Integer.parseInt(second);

Ici, total contient 42. Assembler les chaînes d’origine donnerait « 1230 ». Choisis la conversion selon l’usage prévu de la valeur, et non selon la ressemblance de ses caractères avec des chiffres.

Integer.parseInt(text) renvoie un int ; Long.parseLong(text) renvoie un long. Integer.valueOf("42") renvoie un objet Integer, que Java convertit automatiquement en int lorsqu’un int est nécessaire. Pour une conversion directe de texte en int, parseInt indique clairement le résultat voulu.

Analyse les nombres décimaux et les valeurs de vérité

Double.parseDouble("3.75") renvoie le double 3,75. Son format textuel utilise un point décimal sur tous les ordinateurs, quels que soient les paramètres régionaux. Double.parseDouble("3,5") échoue. Les littéraux du code source Java utilisent aussi un point, même si les méthodes de lecture au clavier peuvent suivre des paramètres régionaux.

Boolean.parseBoolean(text) suit une autre règle : la méthode renvoie true pour « true », quelle que soit la combinaison de majuscules et de minuscules, comme « TRUE ». Tout autre texte donne false, y compris « yes ». La méthode n’interprète pas un mot affirmatif quelconque comme vrai.

Reconnais les textes numériques invalides

Un texte numérique invalide provoque une NumberFormatException pendant l’exécution du programme. Integer.parseInt("4.5") échoue, car un texte décimal ne représente pas un entier. Integer.parseInt("") et Integer.parseInt(" 42") échouent aussi. Le message de l’exception indique le texte qui n’a pas pu être converti.

Le traitement des caractères blancs dépend de la méthode d’analyse. Double.parseDouble ignore les espaces au début et à la fin, tandis que Integer.parseInt ne les ignore pas. Choisis des entrées de test qui révèlent ces différences lors de la lecture des données utilisateur.

Une méthode pratique consiste à lire une ligne entière et à l’analyser :

int age = Integer.parseInt(scanner.nextLine());
double height = Double.parseDouble(scanner.nextLine());

Chaque appel consomme sa ligne entière, y compris la fin de ligne. Cela rend la lecture du texte et celle des nombres cohérentes et évite de mélanger la lecture de jetons et celle de lignes entières.

Convertis un nombre en texte

String.valueOf(42), Integer.toString(42) et "" + 42 produisent tous la String « 42 ». Double.toString(2.50) produit « 2.5 ». L’écriture décimale d’origine ne reste pas attachée au nombre stocké ; cette conversion n’ajoute donc pas de zéro final pour la préserver.

Utilise String.format lorsque tu as besoin de stocker du texte avec un nombre fixe de décimales. Utilise printf lorsque tu veux afficher directement ce texte formaté. Ni un transtypage numérique ni une concaténation simple ne produisent un affichage fixe à deux décimales.

Les entrées au clavier arrivent sous forme de texte. Un Scanner peut lire une ligne entière, un mot ou un mot converti en nombre. Choisis une méthode de lecture cohérente avant de demander des valeurs à l’utilisateur.

Crée un Scanner et lis une ligne

import java.util.Scanner;

public class Greeting {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("What is your name? ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

L’importation se place avant la classe. L’instruction de création se place dans main et relie le Scanner à System.in. Un seul Scanner suffit pour ce programme. nextLine() attend la ligne saisie et renvoie son texte sans le retour à la ligne. Si l’utilisateur saisit « Ada », la dernière instruction affiche « Hello, Ada! ». Utiliser print pour l’invite permet de saisir la réponse à côté de la question.

Choisis entre lignes et jetons

Pour « Ada Lovelace », next() renvoie « Ada ». Un appel ultérieur à nextLine() renvoie « Lovelace », précédé de son espace initiale. Deux appels à nextInt() peuvent lire « 3 4 » sur une même ligne. Un jeton numérique qui ne convient pas à la méthode, comme « 4.5 » ou « abc » pour nextInt(), provoque une InputMismatchException.

Tiens compte de la fin de ligne non lue

Supposons que l’utilisateur saisit « 30 », appuie sur Entrée, puis saisit « Ada Lovelace » et appuie sur Entrée. Ce code ne lit pas le nom comme prévu :

int age = scanner.nextInt();
String name = scanner.nextLine();

nextInt() consomme 30 mais laisse la fin de ligne. nextLine() consomme immédiatement le reste vide de cette même ligne : name vaut donc "". Ajoute scanner.nextLine(); entre les deux instructions pour écarter ce reste avant de lire le nom sur la ligne suivante.

Une autre solution consiste à lire chaque réponse avec nextLine() et à analyser les lignes numériques : int age = Integer.parseInt(scanner.nextLine());. Cela évite d’alterner entre deux unités de lecture différentes.

Précise la convention décimale

nextDouble() suit les paramètres régionaux du Scanner, qui sont initialement les paramètres régionaux de formatage par défaut de l’ordinateur. Des paramètres utilisant la virgule décimale acceptent "3,5" comme nombre décimal et rejettent « 3.5 » dans cet exemple. Pour lire systématiquement des nombres décimaux avec un point, ajoute import java.util.Locale; et crée :

Scanner scanner = new Scanner(System.in).useLocale(Locale.US);

Lire une ligne entière avec Double.parseDouble(scanner.nextLine()) utilise aussi un point. Changer les paramètres régionaux du Scanner ne modifie ni les littéraux du code source Java ni les paramètres régionaux utilisés par les appels ultérieurs à printf.

Lis les valeurs dans l’ordre demandé par les invites. Si tu demandes un nom puis un âge, la première lecture doit stocker le nom. Une lecture mal placée peut soit mettre des données dans la mauvaise variable, soit déclencher une erreur de conversion.

La sortie formatée contrôle la façon dont les valeurs apparaissent dans un message. printf peut afficher un nombre fixe de décimales, ajouter un retour à la ligne et aligner des valeurs en colonnes sans modifier les valeurs stockées.

Fais correspondre les emplacements aux valeurs

Une chaîne de format contient du texte ordinaire et des spécificateurs qui commencent par %. Chaque spécificateur qui consomme une valeur prend la valeur suivante fournie après la chaîne de format :

System.out.printf("%s is %d years old%n", "Ada", 36);

Cette instruction affiche « Ada is 36 years old » et commence une nouvelle ligne. %s affiche du texte ou une autre valeur sous forme de texte, %d affiche un entier tel qu’un int ou un long, et %f affiche une valeur en virgule flottante. %n insère un retour à la ligne sans consommer de valeur. %% affiche un signe pourcentage.

printf n’ajoute pas automatiquement de retour à la ligne. Inclus %n lorsque la sortie suivante doit commencer sur une nouvelle ligne. La séquence d’échappement ordinaire \n représente aussi un caractère de nouvelle ligne dans un texte Java ; %n est le séparateur de ligne du formateur adapté à la plateforme.

Fixe le nombre de décimales à afficher

%f seul affiche six chiffres après le séparateur décimal : le formatage de 2.5 donne « 2.500000 ». La précision de %.2f demande deux décimales :

System.out.printf("Total: %.2f%n", 12.3456);

Avec un formatage américain, la sortie est « Total: 12.35 ». La valeur est arrondie dans le texte affiché. Une variable contenant 12,3456 conserve cette valeur pour les calculs après l’affichage.

Pour System.out.printf("%d items at %.2f each, total %.2f%n", 3, 1.5, 3 * 1.5);, les valeurs remplissent les trois emplacements dans l’ordre. Avec des paramètres américains, la sortie est « 3 items at 1.50 each, total 4.50 ».

Aligne les champs avec une largeur

Une largeur fixe la taille minimale d’un champ. %5d aligne un entier à droite sur au moins cinq caractères ; %-6s aligne du texte à gauche sur au moins six caractères. %6.1f combine une largeur de 6 et une décimale.

System.out.printf("[%5d][%-6s][%6.1f]%n", 42, "Ada", 9.25);

Avec des paramètres américains, la sortie exacte est [ 42][Ada ][ 9.3]. Les crochets rendent visibles les espaces de remplissage. Une valeur plus longue que la largeur prévue reste affichée en entier ; la largeur ne supprime aucun caractère.

Un spécificateur incompatible provoque une erreur d’exécution. printf("%d%n", 2.5) compile, mais lève une IllegalFormatConversionException, car %d attend une valeur entière. Un nombre insuffisant de valeurs, comme dans printf("%d %d%n", 2), provoque une MissingFormatArgumentException.

Choisis entre affichage et texte stocké

String.format applique les mêmes règles de formatage, mais renvoie une String :

String line = String.format("%.1f km", 12.345);

Avec des paramètres américains, line contient « 12.3 km » ; cette instruction n’a rien affiché.

Les deux méthodes de formatage utilisent les paramètres régionaux par défaut, sauf si tu leur en transmets. Ajoute import java.util.Locale;, puis utilise System.out.printf(Locale.US, "%.2f%n", 12.3456); pour obtenir systématiquement « 12.35 » au lieu de "12,35", utilisé avec des paramètres à virgule décimale. String.format peut aussi prendre Locale.US en premier argument. L’affichage d’un double avec println utilise un point indépendamment des paramètres régionaux de formatage.

Un programme de calcul complet relie trois étapes : lire les entrées, effectuer les calculs et afficher les résultats. Planifier les valeurs et leurs unités avant de saisir le code aide à choisir les types et à tester le résultat.

Planifie un programme de calcul de durée de trajet

Les entrées sont la distance en kilomètres et la vitesse moyenne en km/h. Diviser la distance par la vitesse donne la durée en heures. Les deux mesures doivent être de type double pour que la division puisse conserver une fraction. La sortie indiquera les heures et les minutes entières, après arrondi à la minute la plus proche.

import java.util.Scanner;

public class TravelTime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Distance (km): ");
        double distance = Double.parseDouble(scanner.nextLine());
        System.out.print("Speed (km/h): ");
        double speed = Double.parseDouble(scanner.nextLine());
        int totalMinutes = (int) Math.round(distance / speed * 60);
        int hours = totalMinutes / 60;
        int minutes = totalMinutes % 60;
        System.out.println("Travel time: " + hours + " h " + minutes + " min");
    }
}

Pour 150 km à 80 km/h, la division donne 1,875 heure. La multiplication par 60 donne 112,5 minutes. Math.round renvoie le long 113 et le transtypage le convertit en int. La division entière et le reste donnent ensuite 1 heure et 53 minutes. La sortie est « Travel time: 1 h 53 min ».

Si la distance et la vitesse étaient toutes deux de type int, 150 / 80 * 60 produirait 60. La fraction disparaît lors de la division, avant la multiplication. Le choix des types fait partie du plan, pas seulement de l’instruction d’affichage finale.

Choisis séparément l’affichage et les calculs

Pour une addition d’un total de 87,60 partagée entre 4 personnes, stocke le total dans un double et le nombre de personnes dans un int. double share = total / people; donne 21,9. Avec un formatage américain, System.out.printf("Each person pays %.2f%n", share); affiche « Each person pays 21.90 ». Le formatage fournit la deuxième décimale sans modifier le calcul.

Pour les notes entières 7, 8 et 10, double average = (a + b + c) / 3.0; donne 8.333333333333334, affiché sous la forme « 8.33 » avec %.2f. Les parenthèses regroupent le total et le diviseur décimal conserve sa partie fractionnaire.

Teste avec des résultats connus

Calcule les résultats attendus avant d’exécuter le programme. Pour la durée du trajet, 120 km à 60 km/h doivent donner 2 h 0 min. Une distance de 0 km à une vitesse positive doit donner 0 h 0 min. Essaie des entrées proches d’un seuil d’arrondi et des distances valides plus grandes pour tester davantage que le calcul le plus simple.

Inclus des entrées nulles, négatives et grandes lorsque tu vérifies le comportement du programme. Décide si chaque entrée a un sens pour la tâche. Un nombre de personnes égal à zéro fait produire Infinity à total / people lorsque total est un double non nul ; une division entière par zéro lève une ArithmeticException. Une exécution réussie ne garantit pas à elle seule une réponse utile.

Lorsque la sortie diffère de ce que tu attends, affiche les valeurs intermédiaires ou suis-les dans un tableau. Trouve la première valeur incorrecte, corrige l’instruction responsable et relance les tests connus. Compare les espaces et les intitulés ainsi que les nombres.

Utilise des noms comme totalMinutes, des constantes nommées comme MINUTES_PER_HOUR, des unités dans les invites et de courts commentaires qui expliquent le but d’un calcul.