Types de données intégrés en Java

Variables, types de données et littéraux en Java

  Prérequis

Connaître la structure d'un programme Java (classe, méthode main). Avoir des notions de base sur la représentation binaire des nombres.

  Objectifs

Comprendre la notion de variable et d'emplacement mémoire. Maîtriser les huit types primitifs Java, distinguer types primitifs et types référence, et manipuler les littéraux et séquences d'échappement.

1. La notion de variable

// Déclaration seule
int age;

// Déclaration + initialisation
int age = 20;

// Affectation après déclaration
age = 21;

2. Les deux grandes familles de types

3. Les huit types primitifs

3.1 Tableau récapitulatif

3.2 Détail de chaque type

boolean — valeur logique

boolean estConnecte = true;
boolean aReussi    = false;
System.out.println(estConnecte); // true

true

char — caractère Unicode

char lettre  = 'A';
char symbole = '\u03A9'; // Ω (oméga grec)
char chiffre = '7';
System.out.println(lettre);  // A
System.out.println((int) lettre); // 65 (code Unicode)

A
65

byte — entier 8 bits

byte temperature = -5;
byte maxByte     = 127;
// byte erreur   = 200;  dépassement de plage

short — entier 16 bits

short annee    = 2025;
short altitude = -200;

int — entier 32 bits (type par défaut)

int nombreEleves  = 35;
int populationFes = 1_200_000; // _ améliore la lisibilité (Java 7+)
System.out.println(populationFes); // 1200000

1200000

long — entier 64 bits

long populationMondiale = 8_100_000_000L;
long timestampMs        = System.currentTimeMillis();
System.out.println(populationMondiale);

8100000000

float — virgule flottante simple précision

float pi        = 3.14159f;
float temperatureF = -42.3f;

double — virgule flottante double précision (type par défaut)

double moyenne   = 14.75;
double constante = 2.998e8; // notation scientifique : 2.998 × 10^8
System.out.println(constante); // 2.998E8

2.998E8

4. Les types référence

// Déclaration de types référence courants
String nom      = "Mostafa";      // chaîne de caractères
int[]  notes    = {12, 15, 18};  // tableau d'entiers
Etudiant e      = new Etudiant(); // instance de classe

// Valeur par défaut : null
String prenom;          // prenom vaut null
System.out.println(prenom); // null

5. Les littéraux Java

5.1 Littéraux entiers — bases de numération

Les types byte, short, int et long acceptent des littéraux en trois bases :

  Exemple — Quatre notations, même valeur

int decimal = 100;
int octal   = 0144;
int hexa    = 0x64;
int binaire = 0b1100100; // Java 7+

System.out.println(decimal); // 100
System.out.println(octal);   // 100
System.out.println(hexa);    // 100
System.out.println(binaire); // 100

100
100
100
100

5.2 Littéraux de caractères et chaînes

char   lettre   = 'g';         // guillemets simples → char
char   newline  = '\n';        // séquence d'échappement
String message  = "Java 21";  // guillemets doubles → String
String unicode  = "\u03A9";   // Ω — caractère Unicode

5.3 Séquences d'échappement

  Exemple — Séquences d'échappement en pratique

System.out.println("Colonne1\tColonne2\tColonne3");
System.out.println("Ligne 1\nLigne 2\nLigne 3");
System.out.println("Il a dit : \"Bonjour !\"");
System.out.println("Chemin : C:\\Users\\Mostafa");

Colonne1 Colonne2  Colonne3
Ligne 1
Ligne 2
Ligne 3
Il a dit : "Bonjour !"
Chemin : C:\Users\Mostafa

  Complément — Text Blocks (Java 15+)

Depuis Java 15, les blocs de texte permettent d'écrire des chaînes multilignes sans séquences d'échappement, délimités par """ :

String json = """
        {
            "nom": "Mostafa",
            "role": "Professeur"
        }
        """;
System.out.println(json);

{
    "nom": "Mostafa",
    "role": "Professeur"
}

6. Exercice

boolean : true
char    : A
byte    : 100
short   : 1000
int     : 2025
long    : 8100000000
float   : 3.14
double  : 2.718281828
---
100 en décimal     : 100
100 en octal       : 100
100 en hexadécimal : 100
100 en binaire     : 100

public class TypesPrimitifs {
    public static void main(String[] args) {

        // ── Les 8 types primitifs ─────────────────────────
        boolean estActif        = true;
        char    initiale        = 'A';
        byte    score           = 100;
        short   altitude        = 1_000;
        int     annee           = 2025;
        long    populationMonde = 8_100_000_000L;
        float   piApprox        = 3.14f;
        double  e               = 2.718_281_828;

        System.out.println("boolean : " + estActif);
        System.out.println("char    : " + initiale);
        System.out.println("byte    : " + score);
        System.out.println("short   : " + altitude);
        System.out.println("int     : " + annee);
        System.out.println("long    : " + populationMonde);
        System.out.printf ("float   : %.2f%n", piApprox);
        System.out.println("double  : " + e);

        // ── Différentes bases pour la valeur 100 ──────────
        System.out.println("---");
        int decimal = 100;
        int octal   = 0144;
        int hexa    = 0x64;
        int binaire = 0b1100100;

        System.out.println("100 en décimal\t\t: " + decimal);
        System.out.println("100 en octal\t\t: " + octal);
        System.out.println("100 en hexadécimal\t: " + hexa);
        System.out.println("100 en binaire\t\t: " + binaire);
    }
}

boolean : true
char    : A
byte    : 100
short   : 1000
int     : 2025
long    : 8100000000
float   : 3.14
double  : 2.718281828
---
100 en décimal    : 100
100 en octal    : 100
100 en hexadécimal  : 100
100 en binaire    : 100

  L'essentiel en bref

Une variable est un emplacement mémoire nommé, à déclarer avant usage en Java. Le langage propose 8 types primitifs : boolean, char, byte, short, int, long, float, double. Les types référence (objets, tableaux, String…) stockent une adresse et valent null par défaut. Les littéraux permettent d'écrire des valeurs directement dans le code, en décimal, octal (0), hexadécimal (0x) ou binaire (0b). Les séquences d'échappement (\n, \t, \"…) permettent d'insérer des caractères spéciaux dans les chaînes.