Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

1

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.

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

2

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

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

3

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 :

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

4

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

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

5

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

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

6

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 :

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

7

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.

Fichier source

Intel Compilateur Power Pc

Binaire Intel Binaire Mac

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

8

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 :

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.

Fichier source

Compilateur JAVA

Fichier class

Interpréteur java

Chapitre1 : L‘environnement Java et le JDK

Riadh Bouhouchi

9

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.