Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Java

Partie 3 sur 3

Niveau de lecture :

6Java et C++ : ce qui a été retiré

Java est très proche du C++ par sa syntaxe. Il est pourtant plus simple, car les fonctionnalités les plus dangereuses du C++, celles qui sont à l’origine des principales erreurs, ont été supprimées. En voici la liste.

  • Les pointeurs : en C++, un pointeur est une adresse mémoire que l’on manipule soi-même ; une erreur d’adresse donne des plantages ou des failles. Java n’expose pas d’adresses : on manipule des références contrôlées.
  • La surcharge d’opérateurs : en C++, on peut redéfinir le sens de + pour ses propres types. Java l’interdit, sauf pour la concaténation de textes.
  • L’héritage multiple : en C++, une classe peut hériter de plusieurs classes. Java n’autorise qu’un parent, mais une classe peut respecter plusieurs interfaces (des contrats qui listent des actions à fournir).
  • Les destructeurs : devenus inutiles avec le ramasse-miettes.
  • Une gestion des erreurs plus rigoureuse, par les exceptions (voir la gestion des erreurs et des exceptions).
  • Les chaînes de caractères et les tableaux sont des objets du langage, avec des tailles connues, et l’accès hors limites est refusé au lieu de lire une zone voisine.

Cette liste reste fidèle, avec une nuance : le C++ moderne a lui aussi progressé, avec des pointeurs « intelligents » qui se libèrent seuls. L’écart de sécurité s’est réduit mais pas fermé.

7Ranger le code : paquets, import et archives

Programmer en Java consiste à créer des classes. Dans une équipe, empiler des classes dans un seul fichier devient vite ingérable. Java propose donc les paquets (en anglais packages), comparables aux bibliothèques du C et du C++ : un paquet regroupe des classes qui vont ensemble, un peu comme un dossier regroupe des fichiers.

7.1Déclarer un paquet et suivre la hiérarchie

Pour mettre une classe dans un paquet, on commence son fichier par l’instruction package suivie du nom choisi, par exemple package fr.exemple.outils;. Les paquets sont organisés en hiérarchie : on peut les imbriquer, et Java impose que l’emplacement des fichiers suive cette hiérarchie. Un paquet fr.exemple.outils est donc rangé dans les dossiers fr/exemple/outils.

7.2Le classpath : où chercher les classes

Pour que le compilateur et la machine virtuelle trouvent les classes, ils doivent connaître les dossiers où les chercher. Java utilise pour cela une liste de chemins appelée classpath, proche de la variable d’environnement PATH qui indique où chercher les programmes (voir les variables d’environnement). Par défaut, le compilateur et la machine virtuelle cherchent dans le répertoire courant et dans les classes standards.

On voit parfois la variable CLASSPATH définie ainsi : export CLASSPATH = /home/jeff/java:/usr/lib/jdkx.x.x/lib/classes.zip sous Linux et SET CLASSPATH = c:\java;c:\jdkx.x.x\lib\classes.zip sous Windows. Deux corrections s’imposent. Dans l’interpréteur de commandes, il ne faut pas d’espaces autour du signe égal. Et le fichier classes.zip n’existe plus depuis longtemps : la bibliothèque standard est intégrée au JDK. Aujourd’hui, on préfère donner le classpath pour une seule exécution, avec l’option -cp (par exemple java -cp bibliotheques/* PremiereApp), plutôt que de modifier une variable globale. Depuis Java 9, il existe en plus des modules : un niveau de rangement au-dessus des paquets, qui déclare ce qu’un ensemble de paquets expose et ce dont il a besoin.

7.3L’instruction import

Pour utiliser une classe d’un autre paquet, on peut écrire son chemin complet à chaque usage, par exemple java.util.List. C’est vite lourd ; l’instruction import permet de l’écrire une fois : import java.util.List; pour une classe, ou import java.util.*; pour toutes les classes d’un paquet. Un point utile : l’importation avec l’étoile ne rend accessibles que les classes du paquet nommé, pas celles de ses sous-paquets. import monpaquet.*; ne donne donc pas accès à monpaquet.sous.MaClasse. Un exemple que l’on voit parfois contient deux erreurs : il crée un objet Rect avec new Rectangle() (types qui ne correspondent pas) et déclare main sans public, ce qui empêcherait le lancement.

7.4Nommer ses paquets sans collision

Des développeurs du monde entier créent des paquets ; il faut éviter que deux paquets différents portent le même nom. La convention consiste à partir du nom de domaine de l’organisation, écrit à l’envers. Par exemple, un paquet soundstuffs écrit par un site de nom de domaine example.net se nomme net.example.soundstuffs. Pour vos exercices, utilisez un domaine d’exemple comme org.example.

7.5Paquets et accessibilité

L’accessibilité des données et des méthodes d’une classe existe aussi au niveau des paquets. Une classe sans mot-clé d’accès n’est visible que par les classes du même paquet. Pour qu’une classe soit utilisable depuis l’extérieur, elle doit être déclarée public. Le paquet java.lang (qui contient System, String, Math) est importé sans qu’il faille le demander, ainsi que le « paquet par défaut », c’est-à-dire les classes sans déclaration de paquet situées dans les dossiers du classpath. Ce dernier est déconseillé dès que le projet dépasse un exercice.

7.6Les archives JAR

Avec le développement des réseaux, les programmes voyagent : il faut s’assurer qu’ils arrivent intacts, que tous leurs morceaux sont présents et qu’ils occupent peu de place. L’outil jar rassemble les fichiers .class d’un programme dans une seule archive compressée, au format ZIP, dont l’extension est .jar. La syntaxe ressemble à celle de tar sous Unix : jar cvf MonArchive.jar *.class crée l’archive, jar xvf MonArchive.jar l’extrait. Une archive peut contenir un fichier descriptif qui indique la classe de départ, ce qui permet de la lancer avec java -jar MonArchive.jar.

Une applet appelait ses classes depuis une page web en citant l’archive, et l’on recommandait de n’y mettre que les classes nécessaires, car tout était téléchargé en même temps. Le conseil de sobriété reste valable pour tout logiciel livré, mais le cas d’usage a changé : on livre des archives à des serveurs ou à des utilisateurs, plus souvent par un gestionnaire de dépendances (Maven, Gradle) qui télécharge les archives dont un projet a besoin. Cette pratique a une conséquence de sécurité, traitée dans l’encadré cyber.

Pour s’exercer

Exercice 4 : nommer un paquet

Vous travaillez pour l’organisation dont le site est example.org et vous écrivez un outil de calcul de dates. Proposez un nom de paquet, et le dossier où ranger le fichier source.

Voir la réponse

En inversant le domaine : org.example.dates. Le fichier source se range dans le dossier org/example/dates et commence par la ligne package org.example.dates;. L’inversion évite qu’un paquet d’une autre organisation porte le même nom.

Exercice 5 : l’étoile de l’import

Vous écrivez import org.example.*;. Pouvez-vous alors utiliser la classe org.example.dates.Calendrier en l’appelant simplement Calendrier ?

Voir la réponse

Non. L’étoile importe uniquement les classes qui sont directement dans le paquet org.example, pas celles de ses sous-paquets. Il faut écrire import org.example.dates.Calendrier; (ou import org.example.dates.*;).

Exercice 6 : Java est-il plus lent que C++ ?

Un collègue répète que « Java est lent parce qu’il est interprété ». Que répondez-vous ?

Voir la réponse

C’était vrai des premières versions. Aujourd’hui, la machine virtuelle contient un compilateur JIT qui traduit en code machine les parties les plus utilisées pendant l’exécution, souvent en optimisant mieux qu’une compilation faite à l’avance. Pour un serveur qui tourne longtemps, la différence avec le C++ est faible. Java démarre plus lentement et consomme plus de mémoire, et pour du code très proche du matériel, le C++ garde l’avantage.

8La plate-forme Java : ce qui a changé depuis

On présentait autrefois le « Java Framework » comme trois éditions : J2ME (Micro Edition) pour les appareils embarqués comme les assistants personnels et les premiers téléphones, J2SE (Standard Edition) pour les ordinateurs, et J2EE (Enterprise Edition) pour les serveurs d’entreprise. Chacune comprenait une machine virtuelle et un ensemble de classes. Ces trois noms ont été simplifiés (on dit Java SE, Java ME, Java EE), puis le troisième a changé de maison.

CE QUI A CHANGÉ applets petits programmes dans le navigateur abandonnés, retirés du JDK J2EE plate-forme Sun pour les entreprises Jakarta EE, Spring Boot AWT, Swing les deux boîtes à outils graphiques JavaFX, interfaces web versions 1.0, 1.1, 1.2 (dite Java 2) une version tous les 6 mois propriétaire Sun Microsystems Oracle, OpenJDK, Eclipse Le langage est resté très proche de celui d’autrefois ; ce sont l’outillage et le calendrier qui ont changé.
Figure 3. Ce qui a changé dans l’écosystème Java depuis une quinzaine d’années.

8.1La fin des applets

Les applets ont perdu parce que d’autres techniques les ont dépassées : le langage JavaScript et le HTML moderne font dans la page ce que les applets faisaient, sans installer de machine virtuelle (voir JavaScript). Les applets posaient en outre de gros problèmes de sécurité : un module installé dans le navigateur, ouvert à tout code téléchargé depuis le Web, fut une cible permanente des attaquants. Les applets ont été jugées obsolètes en 2016 (Java 9), marquées « à supprimer » en 2021 (Java 17), et leur interface de programmation a été retirée de Java 26 en mars 2026. Cet épisode est un exemple typique : une fonctionnalité utile en 1996 est devenue une surface d’attaque, et la meilleure défense a fini par être de la retirer.

8.2De J2EE à Jakarta EE

J2EE était présenté comme une norme proposée par Sun, portée par un consortium d’entreprises, pour développer des applications d’entreprise « multi-niveaux » basées sur des composants. L’idée est de séparer clairement trois couches : la présentation (l’interface avec l’utilisateur), le métier (les traitements propres à l’activité de l’entreprise) et les données (fichiers, bases relationnelles, annuaires). J2EE définissait les rôles et les interfaces du serveur d’applications, le logiciel qui héberge les programmes, ce qui permettait à des éditeurs tiers de fournir des serveurs compatibles. Il reposait sur des composants distincts, interchangeables et distribués : on étend plus facilement l’architecture, on peut obtenir la haute disponibilité (le service continue malgré une panne), et la maintenance est facilitée.

Voici les principales interfaces de programmation (API, c’est-à-dire des ensembles de fonctions offertes aux programmeurs, voir les API et les services web) de l’époque :

  • Les composants web : les servlets (petits programmes Java qui répondent à des demandes web) et JSP (Java Server Pages, des pages web qui contiennent du Java, voir le Web d’hier).
  • Les composants métier : les EJB (Enterprise Java Beans), chargés des traitements propres à un secteur d’activité et de l’accès aux bases de données.
  • Parmi les services d’infrastructure : JDBC (accès aux bases de données relationnelles, voir le langage SQL), JNDI (accès aux services de noms et aux annuaires d’entreprise, ces carnets d’adresses de l’organisation), JTA (transactions : un groupe d’opérations réussit en entier ou pas du tout), JCA (connexion aux anciens systèmes de l’entreprise) et JMX (supervision des applications).
  • Parmi les services de communication : JAAS (authentification et droits d’accès), JavaMail (envoi de courriers), JMS (échange asynchrone de messages, par un logiciel dit « intergiciel orienté message ») et RMI-IIOP (appels synchrones entre objets distants).

Que reste-t-il de cet ensemble ? En 2017, Oracle a confié J2EE (devenu Java EE) à la fondation Eclipse, qui l’a rebaptisé Jakarta EE, avec un développement ouvert ; les versions suivantes se succèdent depuis. Beaucoup de projets utilisent le cadre de développement Spring et son extension Spring Boot, qui évitent une grande partie de la lourdeur d’origine. Les idées de séparation en couches et de composants interchangeables ont survécu ; les gros serveurs d’applications, eux, ont largement laissé la place à de petits services indépendants (voir les microservices) ou à des conteneurs (voir Docker et Kubernetes). Pour faire communiquer des applications, on utilise couramment des échanges web simples (le style dit REST).

8.3Un langage qui a évolué en douceur

Le langage d’autrefois reste reconnaissable, mais s’est enrichi. On a ajouté la déduction automatique de type avec var (Java 10), les blocs de texte sur plusieurs lignes (Java 15), les enregistrements (records), classes courtes qui ne servent qu’à porter des valeurs (Java 16), les classes scellées qui limitent les héritiers possibles, et la reconnaissance de formes dans les switch (Java 21). Java 21 a aussi apporté les fils d’exécution virtuels (virtual threads), qui permettent à un serveur de traiter des centaines de milliers de demandes en parallèle sans épuiser les ressources du système. Les bibliothèques graphiques AWT et Swing, plus anciennes, existent encore, mais les nouvelles interfaces utilisent plutôt JavaFX, ou, de loin le plus souvent, une interface web.

Dans la version la plus récente, Java 27, plusieurs nouveautés touchent la sécurité et la performance : un échange de clés résistant aux futurs ordinateurs quantiques pour les connexions TLS (voir la cryptographie post-quantique), et un ramasseur de miettes nommé G1 retenu partout par défaut. Certaines autres nouveautés restent en phase d’essai (« préversion »), c’est-à-dire proposées pour être testées mais pas encore garanties.

Pour s’exercer

Exercice 7 : choisir une version

Votre entreprise démarre un nouveau logiciel qui devra vivre cinq ans. Faut-il choisir la version la plus récente de Java, ou une version à support long ? Justifiez.

Voir la réponse

Une version à support long (LTS), par exemple Java 25. Les versions intermédiaires ne reçoivent des corrections de sécurité que quelques mois, ce qui obligerait à migrer tous les six mois. Une version à support long permet de planifier les mises à jour, mais elle doit quand même être mise à jour régulièrement avec les correctifs de sécurité : le support est une promesse de corrections, pas une dispense de les installer.

Sécurité de l’information

Le coin cyber

Cet article décrit comment Java fonctionne et ce qu’il faut surveiller pour l’utiliser sans risque. Il ne contient aucune méthode pour attaquer un programme.

C.1La machine virtuelle ne fait pas tout

Java supprime des familles entières de failles, car il n’existe pas d’adresse mémoire à manipuler et les accès hors des limites d’un tableau sont refusés. Mais le langage ne protège pas contre les erreurs de logique : confiance accordée à une donnée venue de l’extérieur, secrets écrits dans le code, droits trop larges. Les attaques sur les applications web, comme l’injection SQL (voir l’injection SQL) ou le cross-site scripting (voir le XSS), se rencontrent autant en Java qu’ailleurs.

C.2Les dépendances : la surface d’attaque principale

Un projet Java moderne contient souvent plus de code venu de bibliothèques tierces que de code écrit par l’équipe. La faille de Log4j l’a montré. Trois habitudes réduisent le risque : tenir à jour la liste des composants (une « nomenclature logicielle », aussi appelée SBOM, voir la chaîne d’approvisionnement logicielle), faire analyser automatiquement les dépendances à la recherche de failles connues (voir les vulnérabilités et les correctifs), et mettre à jour les versions vulnérables rapidement. En Europe, le règlement sur la cyber-résilience impose des obligations à ceux qui vendent des produits numériques (voir le Cyber Resilience Act).

C.3Désérialisation : ne jamais reconstruire un objet venu d’ailleurs

La sérialisation transforme un objet en suite d’octets pour l’enregistrer ou l’envoyer ; la désérialisation fait l’inverse. Reconstruire des objets à partir de données non fiables peut déclencher l’exécution d’un code non prévu. Le principe de défense est simple : ne pas désérialiser de données qui viennent de l’extérieur avec le mécanisme natif de Java, et préférer des formats d’échange simples, comme JSON (voir XML et JSON), avec une liste précise de ce qui est accepté.

C.4Idée reçue

« Java est sûr parce que le code tourne dans une machine virtuelle. » Faux. La machine virtuelle protège de certaines erreurs de mémoire, mais les applets le montraient déjà : l’idée d’exécuter du code étranger dans un « bac à sable » a été contournée à de nombreuses reprises, et c’est pourquoi la technique a été abandonnée. La sécurité d’une application dépend de ses dépendances, de sa configuration et de la façon dont elle traite les données qu’elle reçoit.

C.5Bonnes pratiques

Développeur

  • Choisir une version à support long et la mettre à jour avec les correctifs.
  • Ne pas faire confiance aux données reçues : valider, limiter, refuser le reste.
  • Ne jamais écrire de mot de passe ou de clé dans le code ni dans le journal.

Organisation

  • Tenir l’inventaire des composants (nomenclature) de chaque logiciel.
  • Analyser les dépendances en continu et fixer un délai maximal pour corriger.
  • Retirer les technologies abandonnées plutôt que les laisser vieillir.

Référentiels : ANSSI, Recommandations de sécurité relatives à la sécurisation des développements · OWASP, Top 10 et Deserialization Cheat Sheet · Règlement (UE) 2024/2847 (Cyber Resilience Act) · CVE-2021-44228.

Références

  1. J. Gosling, B. Joy, G. Steele, G. Bracha, The Java Language Specification, Oracle (édition courante).
  2. T. Lindholm, F. Yellin et al., The Java Virtual Machine Specification, Oracle (édition courante).
  3. OpenJDK, JEP 504 : Remove the Applet API, 2025.
  4. Apache Software Foundation, Apache Log4j Security Vulnerabilities, avis CVE-2021-44228.
  5. Fondation Eclipse, Jakarta EE Platform Specification.
  6. ANSSI, Guide d’hygiène informatique.

Voir aussi

Citer cet article

« Le langage Java », Encyclopédie informatique, révision du 4 novembre 2026.