Types de données Java

Types de données Java

Comme expliqué dans le chapitre précédent, une variable en Java doit être un type de données spécifié :

int myNum = 5;               // Integer (whole number)
float myFloatNum = 5.99f;    // Floating point number
char myLetter = 'D';         // Character
boolean myBool = true;       // Boolean
String myText = "Hello";     // String

Les types de données sont divisés en deux groupes :

• Types de données primitifs - inclut byte, short, int, long, float, double, booleanetchar
• Types de données non primitifs - tels que String , Arrays et Classes (vous en apprendrez plus à ce sujet dans un chapitre ultérieur)

Types de données primitifs

Un type de données primitif spécifie la taille et le type des valeurs de variable, et il n'a pas de méthodes supplémentaires.

Il existe huit types de données primitifs en Java :

Nombres

Les types de nombres primitifs sont divisés en deux groupes :

Les types entiers stockent des nombres entiers, positifs ou négatifs (tels que 123 ou -456), sans décimales. Les types valides sont byte, shortet int . longLe type à utiliser dépend de la valeur numérique.

Les types à virgule flottante représentent des nombres avec une partie fractionnaire, contenant une ou plusieurs décimales. Il en existe deux types : floatet double.

Types entiers

Octet

Le bytetype de données peut stocker des nombres entiers de -128 à 127. Cela peut être utilisé à la place de intou d'autres types d'entiers pour économiser de la mémoire lorsque vous êtes certain que la valeur sera comprise entre -128 et 127 :

byte myNum = 100;
System.out.println(myNum);

Court

Le shorttype de données peut stocker des nombres entiers de -32768 à 32767 :

short myNum = 5000;
System.out.println(myNum);

Int

Le inttype de données peut stocker des nombres entiers de -2147483648 à 2147483647. En général, et dans notre tutoriel, le inttype de données est le type de données préféré lorsque nous créons des variables avec une valeur numérique.

int myNum = 100000;
System.out.println(myNum);

Long

Le longtype de données peut stocker des nombres entiers de -9223372036854775808 à 9223372036854775807. Ceci est utilisé lorsque int n'est pas assez grand pour stocker la valeur. Notez que vous devez terminer la valeur par un "L":

long myNum = 15000000000L;
System.out.println(myNum);

Types à virgule flottante

Vous devez utiliser un type à virgule flottante chaque fois que vous avez besoin d'un nombre avec une décimale, comme 9,99 ou 3,14515.

Flotter

Le floattype de données peut stocker des nombres fractionnaires de 3,4e−038 à 3,4e+038. Notez que vous devez terminer la valeur par un "f":

float myNum = 5.75f;
System.out.println(myNum);

Double

Le doubletype de données peut stocker des nombres fractionnaires de 1,7e−308 à 1,7e+308. Notez que vous devez terminer la valeur par un "d":

double myNum = 19.99d;
System.out.println(myNum);

Numéros scientifiques

Un nombre à virgule flottante peut aussi être un nombre scientifique avec un "e" pour indiquer la puissance de 10 :

float f1 = 35e3f;
double d1 = 12E4d;
System.out.println(f1);
System.out.println(d1);

Booléens

Un type de données booléen est déclaré avec le booleanmot-clé et ne peut prendre que les valeurs trueou false:

boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println(isJavaFun);     // Outputs true
System.out.println(isFishTasty);   // Outputs false

Les valeurs booléennes sont principalement utilisées pour les tests conditionnels, sur lesquels vous en apprendrez plus dans un chapitre ultérieur.

Personnages

Le chartype de données est utilisé pour stocker un seul caractère. Le caractère doit être entouré de guillemets simples, comme 'A' ou 'c' :

char myGrade = 'B';
System.out.println(myGrade);

Vous pouvez également utiliser des valeurs ASCII pour afficher certains caractères :

char myVar1 = 65, myVar2 = 66, myVar3 = 67;
System.out.println(myVar1);
System.out.println(myVar2);
System.out.println(myVar3);

Astuce : Une liste de toutes les valeurs ASCII peut être trouvée dans notre Référence de table ASCII .

Cordes

Le Stringtype de données est utilisé pour stocker une séquence de caractères (texte). Les valeurs de chaîne doivent être entourées de guillemets :

String greeting = "Hello World";
System.out.println(greeting);

Types de données non primitifs

Les types de données non primitifs sont appelés types de référence car ils font référence à des objets.

La principale différence entre les types de données primitifs et non primitifs est :

• Les types primitifs sont prédéfinis (déjà définis) en Java. Les types non primitifs sont créés par le programmeur et ne sont pas définis par Java (sauf pour String).
• Les types non primitifs peuvent être utilisés pour appeler des méthodes afin d'effectuer certaines opérations, contrairement aux types primitifs.
• Un type primitif a toujours une valeur, tandis que les types non primitifs peuvent être null.
• Un type primitif commence par une lettre minuscule, tandis que les types non primitifs commencent par une lettre majuscule.
• La taille d'un type primitif dépend du type de données, tandis que les types non primitifs ont tous la même taille.

Des exemples de types non primitifs sont Strings , Arrays , Classes , Interface , etc. Vous en apprendrez plus à ce sujet dans un chapitre ultérieur.

 myNum = 9;
 myFloatNum = 8.99f;
 myLetter = 'A';
 myBool = false;
 myText = "Hello World";