Types de données de base Java

Les variables s'appliquent à la mémoire pour stocker les valeurs. En d’autres termes, lors de la création d’une variable, vous devez demander de l’espace en mémoire.

Le système de gestion de mémoire alloue de l'espace de stockage aux variables en fonction de leur type, et l'espace alloué ne peut être utilisé que pour stocker des données de ce type.

Par conséquent, en définissant des variables de différents types, des entiers, des décimales ou des caractères peuvent être stockés en mémoire.

Les deux principaux types de données de Java :

• Types de données intégrés

• Type de données de référence

Types de données intégrés

Le langage Java propose huit types de base. Six types numériques (quatre entiers, deux types à virgule flottante), un type caractère et un type booléen.

type d'octet :

• Le type de données octet est un entier signé de 8 bits représenté en complément à deux ;

• La valeur minimale est -128 (-2^7) ;

• La valeur maximale est de 127 (2^7-1) ;

• La valeur par défaut est 0 ;

• Le type byte est utilisé pour économiser de l'espace dans les grands tableaux, remplaçant principalement les entiers, car la variable byte n'occupe qu'un quart de l'espace du type int ;

• Exemple : octet a = 100, octet b = -50.

type court (type entier court) :

• Le type de données court est un entier complémentaire à deux signé de 16 bits.

• La valeur minimale est -32768 (-2^15) ;

• La valeur maximale est 32767 (2^15 - 1) ;

• Le type de données Short peut également économiser de l'espace comme l'octet. Une variable courte représente la moitié de l’espace occupé par une variable de type int ;

• La valeur par défaut est 0 ;

• Exemple : court s = 1000, court r = -20000.

type int (type entier) :

• Le type de données int est un entier signé de 32 bits représenté en complément à deux ;

• La valeur minimale est -2 147 483 648 (-2^31) ;

• La valeur maximale est de 2 147 483 647 (2 ^ 31 - 1) ;

• Généralement, les variables entières sont par défaut de type int ;

• La valeur par défaut est 0 ;

• Exemple : int a = 100 000, int b = -200 000.

long (type entier long) :

• Le type de données long est un entier signé de 64 bits représenté en complément à deux ;

• La valeur minimale est -9 223 372 036 854 775 808 (-2^63) ;

• La valeur maximale est 9 223 372 036 854 775 807 (2^63 -1) ;

• Ce type est principalement utilisé sur les systèmes qui doivent comparer de grands entiers ;

• La valeur par défaut est 0L ;

• Exemple : long a = 100 000L, long b = -200 000L.

float (type à virgule flottante simple précision) :

• Le type de données float est un nombre à virgule flottante simple précision de 32 bits conforme à la norme IEEE 754 ;

• float peut économiser de l'espace mémoire lors du stockage de grands tableaux à virgule flottante ;

• La valeur par défaut est 0,0f ;

• Les nombres à virgule flottante ne peuvent pas être utilisés pour représenter des valeurs précises telles que la devise ;

• Exemple : float f1 = 234,5f.

double (type à virgule flottante double précision) :

• Le type de données double est un nombre à virgule flottante double précision, 64 bits, conforme à la norme IEEE 754 ;

• Le type par défaut des nombres à virgule flottante est double ;

• Le type double ne peut pas non plus représenter des valeurs précises, telles que la devise ;

• La valeur par défaut est 0,0d ;

• Exemple : double d1 = 123,4.

booléen :

• Le type de données booléen représente un bit d'information ;

• Il n'y a que deux valeurs : vrai et faux ;

• Ce type n'est utilisé que comme indicateur pour enregistrer des situations vraies/fausses ;

• La valeur par défaut est false ;

• Exemple : booléen un = vrai.

char (type de caractère) :

• Le type char est un seul caractère Unicode de 16 bits ;

• La valeur minimale est « u0000 » (c'est-à-dire 0) ;

• La valeur maximale est « uffff » (soit 65 535) ;

• Le type de données char peut stocker n’importe quel caractère ;

• Exemple : lettre de caractère = 'A'.

Exemple

Pour la plage de valeurs des types de base des types numériques, nous n'avons pas besoin d'être forcés de nous en souvenir, car leurs valeurs ont été définies dans la classe wrapper correspondante sous forme de constantes. Veuillez consulter l'exemple suivant :

 classe publique PrimitiveTypeTest {
public static void main (String[] arguments) {
// octet
System.out.println("Type de base : octet Chiffres binaires : " + Byte.SIZE);
System.out.println("Classe d'emballage : java.lang.Byte");
System.out.println("Valeur minimale : Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("Valeur maximale : Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();

// court
System.out.println("Type de base : chiffres binaires courts : " + Short.SIZE);
System.out.println("Classe d'emballage : java.lang.Short");
System.out.println("Valeur minimale : Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("Valeur maximale : Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();

// entier
System.out.println("Type de base : int Chiffres binaires : " + Integer.SIZE);
System.out.println("Classe d'emballage : java.lang.Integer");
System.out.println("Valeur minimale : Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("Valeur maximale : Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();

// long
System.out.println("Type de base : long Nombre de chiffres binaires : " + Long.SIZE);
System.out.println("Classe d'emballage : java.lang.Long");
System.out.println("Valeur minimale : Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("Valeur maximale : Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();

// flotter
System.out.println("Type de base : float Nombre de chiffres binaires : " + Float.SIZE);
System.out.println("Classe d'emballage : java.lang.Float");
System.out.println("Valeur minimale : Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("Valeur maximale : Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();

//double
System.out.println("Type de base : double Chiffres binaires : " + Double.SIZE);
System.out.println("Classe d'emballage : java.lang.Double");
System.out.println("Valeur minimale : Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("Valeur maximale : Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();

// char
System.out.println("Type de base : char Chiffres binaires : " + Character.SIZE);
System.out.println("Classe d'emballage : java.lang.Character");
// Sortie Character.MIN_VALUE sur la console sous forme numérique au lieu de caractères System.out.println("Valeur minimale : Character.MIN_VALUE="
+ (int) Caractère.MIN_VALUE);
// Sortie Character.MAX_VALUE sur la console sous forme numérique au lieu de caractères System.out.println("Valeur maximale : Character.MAX_VALUE="
+ (int) Caractère.MAX_VALUE);
}
}

Le résultat de la compilation du code ci-dessus est le suivant :

 Type de base : octet Chiffres binaires : 8
Classe d'emballage : java.lang.Byte
Valeur minimale : Byte.MIN_VALUE=-128
Valeur maximale : Byte.MAX_VALUE=127
Type de base : court Chiffres binaires : 16
Classe d'emballage : java.lang.Short
Valeur minimale : Short.MIN_VALUE=-32768
Valeur maximale : Short.MAX_VALUE=32767


Type de base : int Chiffres binaires : 32
Classe d'emballage : java.lang.Integer
Valeur minimale : Integer.MIN_VALUE=-2147483648
Valeur maximale : Entier.MAX_VALUE=2147483647


Type de base : long Nombre de chiffres binaires : 64
Classe d'emballage : java.lang.Long
Valeur minimale : Long.MIN_VALUE=-9223372036854775808
Valeur maximale : Long.MAX_VALUE=9223372036854775807


Type de base : float Nombre de chiffres binaires : 32
Classe d'emballage : java.lang.Float
Valeur minimale : Float.MIN_VALUE=1.4E-45
Valeur maximale : Float.MAX_VALUE=3.4028235E38


Type de base : double Chiffres binaires : 64
Classe d'emballage : java.lang.Double
Valeur minimale : Double.MIN_VALUE=4.9E-324
Valeur maximale : Double.MAX_VALUE=1.7976931348623157E308


Type de base : char Chiffres binaires : 16
Classe d'emballage : java.lang.Character
Valeur minimale : Character.MIN_VALUE=0
Valeur maximale : Character.MAX_VALUE=65535

Les valeurs minimales et maximales de Float et Double sont affichées sous forme de notation scientifique. Le "E+nombre" à la fin signifie que le nombre avant E doit être multiplié par la puissance "nombre" de 10. Par exemple, 3,14E3 vaut 3,14×1000=3140 et 3,14E-3 vaut 3,14/1000=0,00314.

En fait, il existe un autre type de base void en JAVA, qui a également une classe d'empaquetage correspondante java.lang.Void, mais nous ne pouvons pas opérer directement dessus.

type de référence

• Les variables de type référence sont créées par le constructeur d'une classe et vous pouvez les utiliser pour accéder à l'objet référencé. Ces variables sont spécifiées comme un type spécifique lorsqu'elles sont déclarées, comme Employee, Pubby, etc. Une fois qu'une variable est déclarée, son type ne peut plus être modifié.

• Les objets et les tableaux sont des types de données de référence.

• La valeur par défaut de tous les types de référence est null.

• Une variable de référence peut être utilisée pour faire référence à n’importe quel type compatible.

• Exemple : Animal animal = new Animal("girafe").

Constantes Java

Une constante est une valeur fixe. Ils ne nécessitent pas de calcul et représentent directement les valeurs correspondantes.

Une constante fait référence à une quantité qui ne peut pas être modifiée. Le flag final est utilisé en Java, et la méthode de déclaration est similaire à celle des variables :

 double PI final = 3,1415927 ;

Bien que les noms de constantes puissent également être en minuscules, pour faciliter l'identification, les lettres majuscules sont généralement utilisées pour représenter les constantes.

Les littéraux peuvent être attribués à des variables de n'importe quel type intégré. Par exemple:

 octet a = 68 ;
caractère a = 'A'

Byte, int, long et short peuvent tous être représentés en notation décimale, hexadécimale et octale.

Lors de l'utilisation de constantes, le préfixe 0 indique un octal et le préfixe 0x indique un hexadécimal. Par exemple:

 int décimal = 100 ;
int octal = 0144 ;
int hexa = 0x64 ;

Comme dans d'autres langages, les constantes chaîne de Java sont des séquences de caractères entourées de guillemets. Voici un exemple de chaîne littérale :

 "Bonjour le monde"
"deuxnlignes"
""Ceci est entre guillemets""

Les constantes de chaîne et les constantes de caractère peuvent contenir n'importe quel caractère Unicode. Par exemple:

 char a = 'u0001';
Chaîne a = "u0001" ;

Le langage Java prend en charge certaines séquences de caractères d'échappement spéciales.

Cette section explique les types de données de base de Java. La section suivante explore les différents types de variables et leurs utilisations.