Chapitre : L’environnement JAVA et le JDK

Master Pro SRT : 2018-2019

Objectif :

Ce chapitre vous permettra de connaitre l'historique du langage

JAVA. Outre son historique il vous permettra de reconnaitre
l’environnement de développement JAVA et son mode de
fonctionnement.

1
Riadh Bouhouchi
 Sommaire
Java :....................................................................................................................................................... 3
Le jdk : .................................................................................................................................................... 3
Principe de fonctionnement de JAVA : ................................................................................................... 4
Le fonctionnement habituel avec un langage différent de JAVA : ......................................................... 4
Le fonctionnement du langage JAVA : ................................................................................................... 6
La Machine Virtuelle de Java :................................................................................................................ 6

2
Riadh Bouhouchi
Java :

Le langage Java est un langage orienté objet, qui a vu le jour au sein de la société SUN
Microsystems en 1991.
L‘objectif était de réaliser un langage de programmation pouvant être intégré sur des appareils
électroménagers.
Le langage Java ressemble au langage C++ mais, vu que la programmation avec ce dernier
était compliquée, James Gosling un des auteurs du projet (considéré désormais comme le père
de Java) décida de créer un langage orienté objet, qui avait les mêmes principes de
programmation en C++, qui était facile à programmer et pouvait s‘adapter sur n‘importe
quelles machines.

En parallèle le Web commençait à être utilisé et Java avait ce qu‘il fallait pour s‘adapter avec
un langage rapidement débogué et de petite taille pour pouvoir gagner sur le débit de
transmission du signal en réseaux, en plus pouvait être utilisé sur n‘importe quelles machines
(pc, imprimante, scanner, etc.) qui devaient communiquer entre eux.

Comme résultat nous obtenons un langage:

Proche du C++,
Un langage orienté objet,
Indépendant du système d‘exploitation,
Peut être mis sur n‘importe quelles machines.

Le jdk :

Le Java Development Kit (JDK) est l'environnement dans lequel le code Java est compilé
pour être transformé en bytecode afin que la machine virtuelle Java (JVM) puisse l'interpréter.

Les composants primaires du JDK sont une sélection d'outils de programmation, incluant :

javac – le compilateur, qui convertit le code source en fichier .class (contenant le bytecode
Java)
jar – l'archiveur, qui met sous forme d'un paquetage unique l'ensemble des fichiers class
en un fichier JAR,
javadoc– le générateur de documentation, qui génère automatiquement de la
documentation à partir des commentaires du code source,
jdb – le débogueur.

3
Riadh Bouhouchi
Principe de fonctionnement de JAVA :

Le langage Java est un langage de programmation généraliste et orienté objet devenu maintenant un
produit libre (au sens de la GPL), Il a la particularité d'être compilé en byte-codes, instructions
assembleur d'un processeur virtuel, et donc indépendant du processeur de la machine.

Un programme Java ainsi compilé de façon abstraite, peut alors s'exécuter sur toutes les plate-formes
capables d'émuler ce processeur. Cette caractéristique lui permet de survivre dans un milieu
particulièrement hétérogène comme les machines, serveurs et stations connectés par Internet.

Il existe 2 types de programmes avec la version standard de Java : les applets et les
applications.
Une application autonome (stand alone program) est une application qui s'exécute sous le
contrôle direct du système d'exploitation. Une applet est une application chargée par un
navigateur et qui est exécutée sous le contrôle d'un plugin de ce dernier. Les principales
différences entre une applet et une application sont :
les applets n'ont pas de méthode main() : la méthode main() est appelée par la machine
virtuelle pour exécuter une application.
les applets ne peuvent pas être testées avec l'interpréteur mais doivent être intégrées à
une page HTML, elle même visualisée avec un navigateur disposant d'un plugin
sachant gérer les applets Java, ou testées avec l'applet viewer.

Le fonctionnement habituel avec un langage différent de JAVA :

Avec les langages évolués courants (C++, Pascal, etc.) nous avons pris l‘habitude de coder
sur une machine identique à celle qui exécutera nos applications; la raison est fort simple :
Les compilateurs ne sont pas multi-plateformes et le code généré est spécifique à la machine
qui doit l‘accueillir.
Ainsi, si nous souhaitons distribuer un produit sur plusieurs systèmes, nous devons le
compiler pour chacun de ces systèmes :

4
Riadh Bouhouchi
 Fichier source

Compilateur Intel Power Pc

Binaire Intel Binaire Mac

Nous devons alors utiliser soit n compilateurs différents sur n machines, soit un ou plusieurs
compilateurs multi-plateformes. Outre l‘investissement en matériels et logiciels, la
connaissance de plusieurs systèmes et de leurs outils de développement représente un surcoût
non négligeable.

Cette vision du développement logiciel s‘accordait assez bien aux besoins tant que les
applications produites disposaient d‘une interface homme - machine (HIM) restreinte et que
les sources étaient aisément portables d‘un système à un autre. Les programmes fortran
recouvrent bien cette définition.

Aujourd‘hui, la généralisation des interfaces graphiques et l‘usage de langage plus évolués

compliquent encore davantage le problème. Ainsi pour développer une application destinée à
plusieurs systèmes, il ne faut plus seulement connaître plusieurs compilateurs, mais également
plusieurs systèmes d‘exploitation avec ses différentes couches de librairies et d‘interfaces; les
API (ou librairies de base) de ces interfaces étant toutes différentes.

Ainsi, nos applications sont fortement dépendantes des ressources (y compris graphiques) du
système hôte, des API des interfaces utilisées, et le code produit ne peut s‘exécuter que, sur le
système pour lequel il a été initialement produit.

5
Riadh Bouhouchi
Le fonctionnement du langage JAVA :

Tout d‘abord, Java simplifie le processus de développement : quelque soit la machine sur
laquelle on code, le compilateur fournit le même code.
Ensuite, quelque soit le système utilisé ce code unique est directement opérationnel :

Fichier source

Compilateur JAVA

Fichier class

Interpréteur java

En effet, la compilation d‘une source Java produit un pseudo-code Java qui sera exécuté par
tout interpréteur Java sans aucune modification ou recompilation.
Cet ―interpréteur‖ est couramment dénommé ―machine virtuelle Java‖. De plus en plus,
cette machine virtuelle utilise un compilateur JIT (―Just In Time‖) qui transforme au moment
de l‘exécution, le pseudo-code en code natif afin d‘obtenir la vitesse d‘exécution maximale.

La Machine Virtuelle de Java :

Le jeu d‘instruction de la machine virtuelle Java est optimisé pour être petit et compact.
Destiné à être véhiculé à travers le réseau Internet, il lui a fallut sacrifier rapidité
d‘interprétation pour être de petite taille.
Comme nous l‘avons dit plus haut, le code source Java est compilé en bytecode et stocké dans
un fichier ‗class‘.
Cette opération est réalisée avec l‘outil javac qui n‘est pas un compilateur traditionnel. En
effet, cet outil produit du bytecode, est un format bas niveau qui ne peut être exécuté
directement mais, doit être interprété par chaque ordinateur. C‘est cette étape supplémentaire
qui permet à Java d‘être puissant, flexible et portable.

6
Riadh Bouhouchi
Une instruction bytecode est constituée d‘un code opérateur (opcode), d‘un octet qui identifie
l‘instruction, puis d‘un zéro ou plus d‘opérandes, chacune pouvant peser plus d‘un octet et qui
constitue les paramètres nécessaires à l‘instruction.
Les bytecodes interprètent les données dans la mémoire d‘exécution comme faisant parti d‘un
ensemble limité de types de données. Ces types primitifs sont ceux que manipulent Java :

4 types entiers (byte de 8 bits, short de 16 bits, int de 32 bits, long de 64 bits) ;
1 type non signé (char de 16 bits) ;
2 types flottants (un float de 32 bits, un double de 64 bits) ;
1 type référence à un objet (un type de pointeur sur 32 bits).

Certaines instructions comme dup traitent la mémoire comme des données brutes sans se
préoccuper du type.
Comme dans tous les assembleurs on retrouve les concepts classiques de jeu d‘instructions,
ensemble de registres, pile, heap avec ramasse-miettes ainsi qu‘un espace de stockage pour
les méthodes et un pool de constantes.

Les quatre registres (de 32 bits) sont :

pc (program counter classique),
optop (un pointeur vers le haut de la pile des opérandes),
frame (un pointeur vers l‘environnement d‘exécution de la méthode courante),
vars (pointeur vers la première variable locale de la méthode courante).

La machine virtuelle reposant principalement sur la pile, n‘utilise pas de registres pour passer
et recevoir des arguments. La pile contient l‘état d‘une seule méthode, et est utilisée pour
passer des arguments aux bytecodes et méthodes et pour recevoir leurs résultats.
Le heap est cette partie de la mémoire qui contient les nouvelles instances qui sont allouées.

Les objets Java sont référencés indirectement dans l‘environnement runtime via des handles
qui sont des sortes de pointeurs vers la heap.

7
Riadh Bouhouchi