Types de données en Java : primitifs, types référence et valeurs par défaut

Deux familles : primitifs et références

Toute valeur en Java a un type, et ce type appartient à l'une des deux familles. Les types primitifs contiennent une valeur brute directement : un nombre, un seul caractère ou un vrai/faux. Les types référence contiennent une référence (un pointeur) vers un objet situé ailleurs en mémoire : String, les tableaux et toute classe que vous ou les bibliothèques définissez.

Cette distinction compte parce que les primitifs sont légers et copiés par valeur, tandis que les variables référence pointent vers des objets partagés. Commencez par les huit primitifs : ils sont le fondement sur lequel tout le reste repose.

Les huit types primitifs

Java compte exactement huit types primitifs intégrés. Six sont des nombres, un est un caractère, un est un booléen :

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // entier sur 8 bits,  -128 .. 127
        short  s = 30000;        // entier sur 16 bits
        int    i = 2_000_000;    // entier sur 32 bits (la valeur par défaut pour les entiers)
        long   big = 9_000_000_000L; // entier sur 64 bits - notez le L

        float  f = 3.14f;        // décimal sur 32 bits - notez le f
        double d = 3.141592653589793; // décimal sur 64 bits (la valeur par défaut pour les décimaux)

        char   c = 'A';          // un seul caractère Unicode sur 16 bits
        boolean flag = true;     // uniquement true ou false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Quelques points à remarquer d'emblée : les tirets bas dans 2_000_000 ne sont que des séparateurs visuels ignorés par le compilateur, les suffixes L et f sont obligatoires (voir ci-dessous), et char utilise des apostrophes alors qu'une String utiliserait des guillemets.

Choisir un type numérique

Vous n'avez presque jamais besoin de byte ou short : ils n'économisent de la mémoire que dans d'énormes tableaux. Les vrais choix se font entre int/long pour les entiers et float/double pour les décimaux.

Type	Taille	À utiliser quand
int	32 bits	La valeur par défaut pour les entiers (jusqu'à ~2,1 milliards)
long	64 bits	Valeurs au-delà de ~2 milliards : horodatages en millisecondes, tailles de fichiers
double	64 bits	La valeur par défaut pour les décimaux - bonne précision
float	32 bits	Uniquement quand la mémoire est limitée et que la précision peut en pâtir

Le piège, c'est le dépassement. Un int boucle silencieusement lorsqu'il dépasse sa plage - aucune erreur, juste une réponse fausse :

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // boucle vers un nombre négatif !

        long safe = (long) maxInt + 1;  // on promeut d'abord en long
        System.out.println(safe);
    }
}

maxInt + 1 déborde vers -2147483648 parce que les deux opérandes sont des int et que le résultat reste un int. Convertir un côté en long d'abord effectue le calcul sur 64 bits. Lorsqu'une valeur peut être grande - surtout des millisecondes depuis 1970 - tournez-vous vers long.

Les littéraux et leurs suffixes

Un littéral numérique nu a un type par défaut, et cela piège les gens. 100 est un int ; 3.14 est un double. Pour écrire un littéral long ou float, vous devez ajouter un suffixe :

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // sans le L c'est trop grand pour int -> erreur
        float ratio = 0.5f;               // sans le f le côté droit est un double -> erreur
        double pi = 3.14;                 // correct - les décimaux sont des double par défaut

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Retirez le L de 8_000_000_000L et le code ne compilera pas, car le littéral dépasse la plage de int avant même d'atteindre la variable long. Retirez le f de 0.5f et Java se plaint qu'un double ne peut pas être assigné à un float sans conversion. Le suffixe est insensible à la casse, mais utilisez un L majuscule - un l minuscule ressemble exactement au chiffre 1.

char est un nombre déguisé

Un char stocke une unité de code Unicode sur 16 bits, ce qui signifie qu'il joue aussi le rôle d'un petit entier non signé. Vous pouvez faire de l'arithmétique dessus et le convertir dans les deux sens avec un cast :

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - la valeur Unicode de 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

C'est occasionnellement pratique pour décaler des lettres, mais ne comptez pas dessus pour le texte - c'est à ça que sert String. Notez que char utilise des apostrophes ('A') ; les guillemets ("A") créent une String d'un seul caractère, qui est un type complètement différent.

Valeurs par défaut (et le piège des variables locales)

Les champs et les éléments de tableau que vous n'initialisez pas reçoivent une valeur par défaut sensée. Mais cela ne s'applique qu'aux champs et aux cases de tableau : les variables locales ne reçoivent aucune valeur par défaut, et en utiliser une avant de lui assigner une valeur est une erreur de compilation, pas une surprise à l'exécution.

public class Main {
    static int counter;        // champ -> par défaut 0
    static boolean ready;      // champ -> par défaut false
    static String name;        // champ -> par défaut null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // les éléments du tableau valent 0 par défaut
        System.out.println(nums[0]); // 0
    }
}

Si vous écriviez plutôt int x; System.out.println(x); dans main, le compilateur le rejetterait avec « variable x might not have been initialized ». Cette rigueur est un atout : elle vous empêche de lire des données parasites. Les valeurs par défaut à retenir : les types numériques 0, boolean false, char ' ' et tout type référence null.

Suite : Strings

String est le type référence que vous manipulerez le plus : texte, valeurs concaténées, saisie utilisateur. Il se comporte différemment des primitifs vus ici : c'est un objet, il est immuable, et comparer des chaînes a ses propres pièges. La page suivante le couvre.