JAVA Chapitre1

Chapitre1 : L‘environnement Java et le JDK

MASTER PROFESSIONNEL
NOUVELLES TECHNOLOGIES DES TELECOMMUNICATIONS ET RESEAUX
(N2TR)

Cours JAVA © FST
L’environnement JAVA et le JDK

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
15 ans de Java :........................................................................................................................................ 3
Le jdk : .................................................................................................................................................... 3
Quelques versions et éditions de JAVA : ................................................................................................ 3
Principe de fonctionnement de JAVA : ................................................................................................... 6
Le fonctionnement habituel avec un langage différent de JAVA : ......................................................... 6
Le fonctionnement du langage JAVA : .................................................................................................. 8
La Machine Virtuelle de Java :................................................................................................................ 8

2
Riadh Bouhouchi


15 ans de 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.

Quelques versions et éditions de JAVA :

3
Riadh Bouhouchi


Le langage Java a connu plusieurs évolutions depuis le JDK 1.0 (Java Development Kit) avec
l‘ajout de nombreuses classes et packages à la bibliothèque standard. JDK 1.0 (23 janvier 1996
- 211 classes et interfaces) c‘est la version initiale.
 JDK 1.1 (19 février 1997 - 477 classes et interfaces) De nombreux ajouts avec
notamment :
o une refonte complète du modèle événementiel AWT.
o Les classes internes sont ajoutées au langage.
o JavaBeans.
o JDBC.
o Java Remote Invocation (RMI).
 J2SE 1.2 (9 décembre 1998 - 1 524 classes et interfaces) — Nom de code Playground.
Cette version et les suivantes jusque J2SE 5.0 sont rebaptisées Java 2 et la version
nommée J2SE (Java 2 Platform, Standard Edition) remplace JDK pour distinguer la
plate-forme de base de la version J2EE (Java 2 Platform, Enterprise Edition) et de la
version J2ME (Java 2 Platform, Micro Edition). Plusieurs ajouts dont :
o le mot-clé strictfp
o la réflection
o l‘API graphique Swing est intégrée.
o Pour la première fois, la machine virtuelle Java de Sun inclut un compilateur
« Juste à temps » (Just in Time).
o Java Plug-in
o Java IDL, une implémentation de IDL pour l‘interopérabilité avec CORBA.
o le framework Collections.
 J2SE 1.3 (8 mai 2000 - 1 840 classes et interfaces) Nom de code Kestrel.
Changements principaux :
o HotSpot JVM inclus (La machine virtuelle HotSpot sortit en avril 1999 pour la
machine virtuelle du J2SE 1.2)
o Changement pour les RMI pour être basé sur CORBA.
o JavaSound
o JNDI (Java Naming and Directory Interface) disponible auparavant comme
extension
o JPDA (Java Platform Debugger Architecture)
 J2SE 1.4 (6 février 2002 - 2 723 classes et interfaces) — Nom de code Merlin. Ce fut la
première révision de la plate-forme sous JCP (Java Community Process). Les
principaux changements sont :
o le mot-clé assert (Spécifié dans JSR 41.)
o les expressions rationnelles modélisées en s‘inspirant du langage Perl.
o Le chaînage d‘exception permet à une exception d‘encapsuler l‘exception de
base niveau d‘origine. (Spécifié dans (en) JSR 51.)
o API de journalisation (Spécifiée dans (en) JSR 47.)
o l‘API Image I/O pour lire et écrire des flux.
o Intégration d‘un parser XML et du moteur XSLT nommé JAXP (Spécifié dans
(en) JSR 5 et (en) JSR 63.)
o Intégration des extensions de sécurité JCE (Java Cryptography Extension), JSSE
et JAAS.
o Java Web Start (introduit pour la première fois en mars 2001 pour J2SE 1.3 -
Spécifié dans (en) JSR 56.)
 J2SE 5.0 (30 septembre 2004 - 3 270 classes et interfaces) — Nom de code Tiger.
(initialement numérotée 1.5, qui est toujours utilisé comme numéro de version

4
Riadh Bouhouchi


interne). Développé par (en) JSR 176, Tiger ajoute un nombre significatif de
nouveautés au langage :
o Programmation générique — (Spécifié par (en) JSR 14.)
o Metadata — également appelées annotations, permet au langage de construire
des classes et des méthodes étiquetées avec des données additionnelles qui
peuvent être utilisées en tant que méta-données (Spécifiée dans (en) JSR 175.)
o Autoboxing/unboxing — conversion automatique entre des types primitifs
(comme le type int) et le Wrapper de classe correspondant (comme la classe
Integer) (Spécifié dans (en) JSR 201).
o Énumérations — le mot-clé enum permet de créer une liste ordonnée de valeurs
sans type. Auparavant, ceci pouvait seulement être réalisé par des entiers
constants (Spécifié dans JSR 201).
o Varargs — la syntaxe Object … utilisée dans une déclaration de méthode permet
de spécifier un nombre variable d‘arguments pour cette méthode. C‘est un
fonctionnement équivalent à la fonction « printf » en C.
o Imports statiques — Cette fonctionnalité permet d‘utiliser les constantes d‘une
classe sans spécifier le nom de cette classe et sans passer par « l‘anti-pattern
Constant Interface » (c‘est l‘expression utilisée sur le site de Sun).
o Extension du for pour les boucles — la syntaxe du for est étendue avec une
syntaxe spéciale pour itérer sur n‘importe quel objet itérable comme un
tableau, ou une collection en utilisant la syntaxe :

void displayWidgets (Iterable<Widget> widgets) {
for (Widget w : widgets) {
w.display();
}
}

cet exemple parcourt le contenu de l‘objet widgets de la classe Iterable et contenant
uniquement des références vers des objets de la classe Widget, assignant chacun de ces
éléments à la variable w et ensuite appelle la méthode display( ) sur l‘élément w (spécifié
dans JSR 201).
 Java SE 6 (11 décembre 2006 - 3 777 classes et interfaces) Nom de code Mustang.
Une version bêta est sortie le 15 février 2006, une autre bêta en juin 2006, une version
« release candidate » en novembre 2006, et la version finale le 12 décembre 2006.
Avec cette version, Sun remplace le nom J2SE par Java SE et supprime le .0 au
numéro de version.
 Java SE 7 — Nom de code Dolphin. Une des nouveautés majeures de cette version
sera l‘ajout des closures (en cours de spécifications). Il s‘agira de la première version
sous la licence GPL. Sortie pressentie pour début 2010.
En plus des changements au niveau du langage, des changements plus importants ont eu lieu
au fil des années qui ont conduit des quelques centaines de classes dans le JDK 1.0 à plus de
3 000 dans J2SE 5.0. Des API entières, comme Swing ou Java2D ont été ajoutées et beaucoup
de méthodes de l‘original JDK 1.0 ont été déclarées deprecated (c‘est-à-dire obsolètes et
pouvant être supprimées à tout moment).

5
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 :

6
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.

7
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.
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.

8
Riadh Bouhouchi


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.

9
Riadh Bouhouchi

JAVA Chapitre1

Contenu connexe

Tendances

En vedette

Similaire à JAVA Chapitre1

Plus de Mohamed Ferchichi

Dernier

JAVA Chapitre1