Java Academy · Leçon

Types primitifs ou enveloppes

Integer, Double, Boolean et leurs équivalents

Types primitifs ou enveloppes est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Deux univers de valeurs

Java possède des types primitifs comme int, double et boolean, qui contiennent directement des valeurs brutes. Il possède également des classes enveloppes comme Integer, Double et Boolean, qui encapsulent ces valeurs dans des objets.

Les primitifs sont rapides et légers. Les enveloppes sont des objets à part entière qui peuvent être placés dans des collections et peuvent être null.

Les huit types primitifs

Java définit exactement huit types primitifs :

byte, short, int, long pour les nombres entiers
float, double pour les nombres décimaux
char pour un seul caractère
boolean pour vrai ou faux

Chacun possède une classe enveloppe correspondante dans le paquetage java.lang.

Noms correspondants des enveloppes

La plupart des noms d’enveloppes s’obtiennent en mettant le primitif en majuscule, mais deux noms diffèrent :

int devient Integer
char devient Character
boolean devient Boolean, double devient Double, et ainsi de suite

Affichons quelques enveloppes.

public class Main {
    public static void main(String[] args) {
        Integer count = 42;
        Double price = 9.99;
        Boolean active = true;
        Character grade = 'A';
        System.out.println(count);
        System.out.println(price);
        System.out.println(active);
        System.out.println(grade);
    }
}

Les enveloppes sont des objets

Un primitif contient une valeur. Une enveloppe est une référence d’objet ; elle peut donc ne pointer vers rien du tout avec null.

Les enveloppes sont ainsi utiles lorsqu’une valeur peut être absente, par exemple dans une colonne de base de données qui autorise NULL.

public class Main {
    public static void main(String[] args) {
        Integer missing = null;
        int present = 5;
        System.out.println(missing);
        System.out.println(present);
    }
}

Constantes utiles

Les classes enveloppes exposent des constantes pratiques. Integer.MAX_VALUE et Integer.MIN_VALUE donnent les valeurs maximale et minimale de int.

C’est bien plus facile que de mémoriser vous-même ces nombres.

public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }
}

Méthodes auxiliaires

Les classes enveloppes sont également des boîtes à outils contenant des méthodes auxiliaires statiques. Par exemple, Integer.toBinaryString affiche un nombre en base 2, et Integer.max renvoie la plus grande de deux valeurs.

public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.max(7, 3));
        System.out.println(Integer.toHexString(255));
    }
}

Pourquoi les collections ont besoin d’enveloppes

Les types génériques de Java fonctionnent uniquement avec des objets, et non avec des primitifs. Vous ne pouvez pas écrire List<int>.

À la place, utilisez List<Integer>. L’enveloppe permet à la valeur primitive d’entrer dans l’univers des objets requis par les collections.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        System.out.println(numbers);
    }
}

Comparer des valeurs enveloppes

Pour comparer la valeur numérique contenue dans deux enveloppes, utilisez .equals() ou .compareTo(), et non les opérateurs mathématiques directement sur les objets.

compareTo renvoie un nombre négatif, zéro ou un nombre positif.

public class Main {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 200;
        System.out.println(a.equals(b));
        System.out.println(a.compareTo(b));
    }
}

Mémoire et performances

Les primitifs utilisent moins de mémoire et s’exécutent plus rapidement, car ils n’ont pas le coût supplémentaire des objets. Un seul int n’est que 4 octets de données brutes.

Un objet enveloppe contient des informations d’en-tête supplémentaires. Pour les boucles intensives parcourant des millions de valeurs, préférez les primitifs.

Des valeurs par défaut différentes

Un champ primitif non initialisé reçoit par défaut une valeur proche de zéro : int vaut 0 et boolean vaut false.

Un champ enveloppe non initialisé reçoit par défaut null. Cette différence est importante lorsque vous essayez ensuite d’utiliser la valeur.

public class Main {
    static int primitiveField;
    static Integer wrapperField;

    public static void main(String[] args) {
        System.out.println(primitiveField);
        System.out.println(wrapperField);
    }
}

Choisir entre les deux

Une règle simple : utilisez les primitifs par défaut pour les performances et la clarté. Passez à une enveloppe lorsque vous avez besoin d’un élément de collection, d’un type générique ou de la possibilité de représenter une valeur absente avec null.

Vérification rapide

Évaluez votre compréhension des primitifs et des enveloppes.

Récapitulatif

Vous avez appris la différence entre les primitifs et les enveloppes :

Les huit primitifs correspondent à huit classes enveloppes, comme Integer et Double
Les enveloppes sont des objets, peuvent être null et peuvent être placées dans des collections
Les primitifs sont plus rapides et plus légers : utilisez-les donc par défaut
Les classes enveloppes fournissent également des constantes et des méthodes auxiliaires utiles

Questions Fréquemment Posées

La leçon « Types primitifs ou enveloppes » est-elle gratuite ?

Oui — le texte complet de « Types primitifs ou enveloppes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Types primitifs ou enveloppes » ?

Integer, Double, Boolean et leurs équivalents Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Types primitifs ou enveloppes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy