(Java) Variables. Formats de sortie


Un ordinateur ne serait pas nécessaire s'il n'avait pas la capacité de stocker diverses informations dans sa mémoire et de pouvoir traiter des informations du même type en utilisant les mêmes algorithmes. 
Afin de créer des programmes plus intéressants, il faut apprendre à stocker des informations dans la mémoire de l'ordinateur. En même temps, nous devons apprendre à accéder d'une manière ou d'une autre aux cellules de mémoire de l'ordinateur. 
En programmation, comme dans la vie, pour faire référence à n'importe quelle partie de la mémoire de l'ordinateur, cela se produit par son nom. En utilisant ce nom, vous pouvez à la fois lire des informations et les y écrire.

Une variable est un emplacement dans la mémoire de l'ordinateur qui a un nom et stocke une valeur correspondant au type.

Le mot "variable" nous indique que sa valeur peut changer pendant l'exécution du programme.  Lorsqu'une nouvelle valeur de variable est enregistrée, l'ancienne est effacée


Pour un ordinateur, toutes les informations sont des données dans sa mémoire - des ensembles de zéros et de uns (pour le dire simplement, toute information dans un ordinateur n'est que des nombres, et il les traite de la même manière). Cependant, nous savons que les nombres entiers et les nombres fractionnaires fonctionnent différemment. Par conséquent, chaque langage de programmation possède différents types de données, qui sont traitées à l'aide de différentes méthodes.

Par exemple,
entier variables – tapez int (de l'entier anglais – entier), occupez 4 octets en mémoire ;
- les variables réelles qui peuvent avoir une partie fractionnaire (type float – de l'anglais flottant – flottant) occupent 4 octets en mémoire< br /> - caractères (type car – du caractère anglais – symbole), occupent 1 octet en mémoire

Essayons d'ajouter une variable à notre programme.
Avant d'utiliser une variable, vous devez dire à l'ordinateur de lui allouer de l'espace en mémoire. Pour cela, la variable doit être déclarée, c'est-à-dire préciser quel type de valeur elle va stocker, et lui donner un nom.
De plus, si nécessaire, vous pouvez lui attribuer des valeurs initiales. 

Prenons un programme comme exemple
classe publique Main {  
    public static void main(String[] args) {  
        entier a=6, b ;  //deux variables de type entier ont été déclarées dans la variable a et ont immédiatement enregistré la valeur 6. La variable b n'a pas été mise à la valeur initiale ; ce qui sera dans la mémoire dans ce cas, nous ne savons pas.
    }
}

Maintenant, essayez-le vous-même.

Essayons d'écrire une calculatrice pour les nombres premiers

Notre tâche est d'afficher une expression arithmétique sur l'écran et de la faire calculer par l'ordinateur.
Par exemple : 
5+7=12
De plus, au lieu de 5 et 7, il peut y avoir des nombres différents, en fonction des valeurs des variables a et b dans le programme.

Dans l'instruction de sortie, vous pouvez afficher non seulement du texte, mais également les valeurs des variables, ainsi que le résultat d'une expression arithmétique. De plus, la séquence de sortie peut être différente. Par exemple, pour afficher l'expression ci-dessus, vous devez l'écrire comme ceci : System.out.print(a+"+"+b+"="+(a+b)); Si nous voulons afficher la valeur d'une variable, il suffit de spécifier son nom sans les guillemets. Si nous voulons afficher le résultat d'une expression arithmétique, il suffit d'écrire correctement l'expression arithmétique.
*** Approfondissement : entrée formatée ***
Dans la chaîne de format, le nombre de spécificateurs de sortie n'est pas limité, l'essentiel pour chaque spécificateur après la chaîne de format est de répertorier toutes les valeurs séparées par des virgules, qui seront remplacées par le modèle. Par exemple : System.out.printf("%d+%d=%d",a,b,a+b); La chaîne de format spécifie trois spécificateurs pour imprimer des valeurs entières à la place.  ; L'ordre de substitution est direct.  Ceux. à la place du premier modèle %d la valeur de la variable a sera affichée ; au lieu de la seconde -  la valeur de la variable b ; et  au lieu du troisième - la valeur de l'expression a+b Et maintenant nous allons écrire un programme qui affiche le résultat des opérations arithmétiques de base avec ces variables

Pour que l'utilisateur puisse définir lui-même la valeur de la variable, il est nécessaire de pouvoir saisir des valeurs à partir du clavier. Pour cela, l'objet in est utilisé, qui s'écrit comme suit : Scanner in = nouveau Scanner(System.in); Mais pour que cela fonctionne, vous devez d'abord l'importer en utilisant import java.util.Scanner

Pour obtenir une valeur entière, utilisez   in.nextInt();, dont le résultat doit être affecté à une variable.
Par exemple,  int a = in.nextInt();
Il existe d'autres méthodes pour d'autres types de données : 
  • next() : lit la ligne d'entrée jusqu'au premier espace
  • nextLine() : lit toute la ligne d'entrée
  • nextInt() : lit l'int saisi
  • nextDouble() : lit le double d'entrée
  • nextBoolean() : lit une valeur booléenne
  • nextByte() : lit l'octet du nombre saisi
  • nextFloat() : lit le flottant saisi
  • nextShort() : lit le nombre saisi court

*** matériel approfondi : pour ceux qui s'intéressent au langage Java ***
Des spécificateurs de sortie supplémentaires vous permettent de contrôler la sortie des nombres dans certains formats.

Largeur de champ minimale
Exemple :
%04d  ; - le numéro sera affiché sur 4 positions, s'il y a moins de quatre chiffres, alors les premiers seront des zéros
int a=34 ; System.out.printf("%04d",a); //à l'écran : 0 0 3 4  ;  
Le trait de soulignement est placé ici spécifiquement pour l'affichage visuel de la sortie du nombre.   

%4d &ndash ; le même, mais au lieu de zéros, il y aura des espaces
int a=34 ; System.out.printf(“%4d”,a); //à l'écran :      3 4 < /code>

Sortir avec une certaine précision - utilisé pour générer des nombres réels. Par défaut, les nombres réels sont affichés avec une précision allant jusqu'à 6 décimales. Mais il y a des cas qui doivent être sortis avec une précision différente. Dans ce cas, vous devez spécifier le nombre de places de familiarité à allouer au numéro lui-même et le nombre après la virgule.
Par exemple,
%9.3f   ; - un nombre réel sera affiché sur 9 positions, avec trois décimales.

double a=34.24356 ; System.out.printf("%9.3f",a); // à l'écran : _ _ _ 3 2 . 2 4 4

Essayons d'utiliser ces informations dans la pratique.

Ce matériel est destiné à une étude plus approfondie. Nous analyserons comment imprimer des variables à l'aide de l'opérateur de sortie Java (printf)
*** Matériau profond ***


Comment afficher la valeur d'une variable à l'écran ?
Pour ce faire, à l'intérieur de la chaîne de format dans l'instruction de sortie, vous devez spécifier un modèle, à la place duquel la valeur de la variable sera affichée.
Le modèle à utiliser dépend du type de variable. 
Ces modèles sont appelés spécificateurs de sortie et sont présentés dans le tableau. Un nombre suffisant de spécificateurs sont donnés. Il n'est pas nécessaire de tous les mémoriser. 
Dans la plupart des cas, nous utiliserons des spécificateurs pour générer des entiers, des nombres réels, ainsi que des caractères et des chaînes. Mais vous pouvez revenir à cette leçon à tout moment et voir le modèle dont vous avez besoin.
 
Code Formater
%c Symbole
%d Entier décimal signé
%i Entier décimal signé
%e Format scientifique (e minuscule)
%E Format scientifique (E majuscule)
%f Flotteur réel
%g Selon le format le plus court, %e ou %f est utilisé
%G Selon le format le plus court, %E ou %f est utilisé
%o Octal signé
%s Chaîne de caractères
%u Entier décimal non signé
%x Numéro hexadécimal non signé (minuscule)
%X Numéro hexadécimal non signé (majuscule)
%p Index
%n Pointeur vers une variable entière. Le spécificateur fait que cette variable entière se voit attribuer le nombre de caractères imprimés avant elle
%% Signe %                           

Ajouts :
Pour afficher des variables comme short int  le modificateur h est utilisé (par exemple, \(\%hd\))
Pour afficher les valeurs des variables de type long int, utilisez le modificateur l (par exemple, \(\%ld \))< br /> Le modificateur L peut être utilisé comme préfixe avant les spécificateurs e, f, g. Cela signifie qu'une valeur de type long double est affichée à l'écran.  (par exemple \(\%Lf\))

Regardons un exemple pratique

 

Pour  la sortie d'un nombre réel était garantie avec un point comme séparateur, vous devez utiliser la disposition américaine, qui est liée à :
  Paramètres régionaux.setDefault(Paramètres régionaux .États-Unis);