Langage Java

par Patrick BELLOT

Docteur d’État en informatique
Professeur à l’École nationale supérieure des Télécommunications
et Christophe MATIACHOFF
Docteur de l’université Pierre-et-Marie-Curie
IBM Global Services - CGI Informatique, centre de Compétences Objet

1. Le langage orienté objet Java ............................................................... H 3 088 - 2

1.1 Caractéristiques ............................................................................................ — 2
1.2 Conclusions................................................................................................... — 7
2. Les paquetages Java................................................................................ — 7
2.1 Le paquetage java.lang ................................................................................ — 7
2.2 Les paquetages utilitaires ............................................................................ — 7
2.3 Le paquetage java.applet............................................................................. — 7
2.4 Le paquetage java.awt et les paquetages dérivés ..................................... — 7
2.5 Les paquetages java.io et java.net .............................................................. — 7
2.6 Le paquetage java.rmi et les paquetages associés ................................... — 8
2.7 Le paquetage java.sql .................................................................................. — 9
2.8 Le paquetage java.beans ............................................................................. — 9
2.9 Le paquetage java.lang.reflect .................................................................... — 9
2.10 Le paquetage java.security et les paquetages associés............................ — 9
2.11 Conclusions................................................................................................... — 9
3. Java et la sécurité .................................................................................... — 9
3.1 Les restrictions par le langage .................................................................... — 9
3.2 L’analyse du bytecode .................................................................................. — 9
3.3 La maîtrise du chargement des classes...................................................... — 9
3.4 Les restrictions sur les applets .................................................................... — 9
3.5 Les applets signées ...................................................................................... — 10
3.6 Conclusions................................................................................................... — 10
4. Mythes et réalités ..................................................................................... — 10

Pour en savoir plus ........................................................................................... Doc. H 3 088

ava est le dernier né des langages de programmation orientée objet. Il n’est

J pas un journal relatif à l’informatique qui ne présente régulièrement des
articles concernant le langage Java. Java envahit l’industrie et les projets sont
nombreux. Il y a peu de projets réels mais beaucoup de prototypes de validation
de la technologie. Le deuxième symposium Java qui s’est tenu à Berlin fin 1997
a vu la présentation de nombreux produits. Les constructeurs et les sociétés de
logiciels s’investissent dans la technologie Java. Aucun colloque concernant la
programmation orientée objet ne peut faire l’impasse sur Java. Enfin, Java con-
quiert les universités et les écoles où sa publicité, alliée à une certaine simplicité
de programmation pour des résultats spectaculaires, induit la demande des élè-
ves. Nous allons présenter Java, sa technologie et examiner objectivement les
raisons de ce succès.
Le langage Java et ses concepts ont été développés par Sun Microsystems Inc.
Les concepts ont été pour l’essentiel empruntés aux langages orientés objet
existants. Un site Web maintient à jour les informations sur Java, son historique
et ses nouveaux développements. Ces derniers sont si rapides qu’il est pratique-

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
© Techniques de l’Ingénieur, traité Informatique H 3 088 − 1
LANGAGE JAVA ________________________________________________________________________________________________________________________

ment impossible d’obtenir une information à jour sans la consultation régulière

de ce genre de sites. Même si Java n’est pas exclusivement un langage de déve-
loppement pour Internet, il a grandement facilité la programmation répartie,
celle des interfaces graphiques et celle des « applets », petits programmes exé-
cutés par les « navigateurs Internet ». De fait, la vie de Java se passe sur Internet.
C’est là qu’il faut chercher les dernières nouveautés, demander des aides en cas
de doute, rechercher les derniers outils de développement ou les bibliothèques
récentes.
Le concept Java a été développé par l’équipe de James Gosling de Sun Micro-
systems Inc. dans le but d’obtenir des programmes téléchargeables et indépen-
dants du support d’exécution, machine et système d’exploitation. Le marché
ciblé est celui des machines portables de faible capacité mais pouvant être
connectées au réseau. Il est aussi celui des navigateurs Web qui ont besoin
d’interactivité pour n’être plus de simples afficheurs d’informations multimé-
dias. Il leur faut donc être programmables à partir des serveurs où ils vont cher-
cher l’information. Les promoteurs de Java en disent que c’est un langage
orienté objet, simple, réparti, robuste, sûr, indépendant de l’architecture, por-
table, efficace, « multithread » et dynamique.

1. Le langage orienté objet public class Point {

Java private int x,y ; // les coordonnŽes du point

// dŽplacer un point

Java fait partie de la famille des langages orientés objet qui
regroupe Eiffel, C++, SmallTalk, Clos et quelques autres dont Ada
qui intègre à présent certains concepts de l’orienté objet. Sa syntaxe
est proche de celle de C++ [6] mais l’analogie avec C++ ne doit pas
être faite trop rapidement. Sur le fond, la parenté est bien plus
grande avec SmallTalk [9]. Être orienté objet signifie qu’en dehors
des types de base prédéfinis tels que les nombres ou les caractères,
tout est objet. Les programmes sont constitués par assemblages
des composants logiciels que sont les objets. L’objet est la réunion
dans une même entité d’une structure de donnée et des algorithmes
permettant de manipuler cette structure de donnée. Cette idée
s’oppose à celle de la programmation conventionnelle où données
et traitements sont séparés. L’objet prolonge la célèbre équation de
N. Wirth [13] Program = Data Structures + Algorithms. L’objet se dis-
tingue du paquetage [3] de la programmation modulaire par l’outil
de sa déclaration, la classe, et par la manière d’exécuter les pro-
grammes. Enfin, il s’en distingue par le concept d’héritage qui per-
met de créer des objets par spécialisation du modèle d’autres
objets.
1.1 Caractéristiques
Les classes.
Une classe est le type d’un objet. Tout objet appartient à une
classe, on dit qu’il est instance de cette classe. La figure 1 donne la
déclaration d’une classe Point décrivant un point comme ayant
deux coordonnées x et y de type entier et connaissant une procé-
dure moveTo(nx,ny) permettant de déplacer le point. De telles pro-
cédures ou fonctions décrites dans la classe sont appelées des
méthodes tandis que les données décrites dans la classe sont appe-
lées des attributs, des champs ou encore des variables d’instance.
Les méthodes et les attributs sont communs à toutes les instances,
tandis que chaque objet possède ses propres valeurs d’attributs.
public void moveTo(int nx, int ny) {
x = nx ;
y = ny ;
}
}
Figure 1 – Une classe Point
Les objets : création et référence.
Un objet pour exister doit être créé à partir de sa classe. La créa-
tion se fait à l’aide mot clef new suivi du nom de la classe et d’une
paire de parenthèses. Ainsi l’expression new Point() a comme
valeur une référence sur un objet créé de la classe Point. Notons,
que comme en Eiffel [15], la notion de pointeur n’existe pas en Java,
elle est remplacée par celle équivalente de référence. Notons
également qu’il n’est pas possible d’effectuer d’opération sur les
références comme nous pourrions le faire sur des pointeurs en C ou
en C++. Ces opérations sont une source bien connue de bogues. En
Java, comme en C++, et contrairement à Smalltalk, les types de base
tels que les nombres, les caractères ou les booléens ne sont pas
considérés comme des objets à part entière. Ils possèdent une
sémantique par valeur et non par référence : c’est une copie des
types de base qui est passée comme argument des envois de mes-
sages, et non une référence.
Les variables.
Les variables doivent être déclarées avec leur type avant toute
utilisation. Une variable ayant pour type une classe est destinée à
contenir une référence sur les objets de cette classe. Initialement,
elle contient la référence null qui ne référence aucun objet. Ainsi,
on pourrait écrire :
Point p ; // la variable p contient la rŽfŽrence null
p = new Point() ; // p contient une rŽfŽrence sur un Point crŽŽ

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
H 3 088 − 2 © Techniques de l’Ingénieur, traité Informatique
_______________________________________________________________________________________________________________________
public class Point {
private int x,y ; // les coordonnŽes du point
// premier constructeur
public Point() {
moveTo(0,0) ;
}
// deuxi•me constructeur
public Point(int ix, int iy) {
moveTo(ix,iy) ;
} d’exécution, etc. Ce programme est exécuté en tâche de fond de très
// dŽplacer un point
public void moveTo(int nx, int ny) {
x = nx ;
y = ny ;
} sources liées à cet objet. Ainsi, si l’objet contient un descripteur de
// calculer la distance ˆ l'origine (0,0)
public int distOrigin() {
return((int)Math.sqrt(x*x+y*y)) ;
}
} d’héritage qui distingue réellement la classe du paquetage. On peut
Figure 2 – La classe Point avec des constructeurs
Envoi de message.
Une méthode est toujours déclarée dans une classe et est exécu-
tée par un envoi de message à un objet de la classe. Un envoi de
message peut être assimilé à un appel de procédure classique qui
s’effectuerait dans le contexte d’un objet particulier, celui du rece-
veur du message. Ainsi l’instruction p.moveTo(23,1024) est
l’envoi du message moveTo(23,1024) au point p, qui a pour effet
de déplacer p en attribuant les valeurs 23 et 1024 à ses coordonnées
x et y. Notons que les méthodes peuvent avoir des résultats et être
utilisées comme des fonctions. Ainsi la méthode distOrigin()
décrite figure 2 peut s’utiliser dans un appel int n = p.distOri-
gin() puisque son résultat est de type entier.
Les constructeurs.
La pratique de la programmation nous apprend qu’il est toujours
préférable d’initialiser ses données. Par défaut, nombres et carac-
tères seront initialisés à zéro, les booléens à faux tandis que les
variables ayant pour type une classe sont initialisées avec la réfé-
rence null. L’initialisation d’un objet est réalisée par des méthodes
spéciales appelées constructeurs. Un constructeur a toujours
comme nom celui de sa classe, n’a pas de type de retour et peut pos-
séder des paramètres quelconques. Une classe peut avoir différents
constructeurs. Dans la figure 2, on a ajouté deux constructeurs à la
classe Point. Le premier sans arguments initialise les coordonnées
à 0, 0. Le deuxième initialise les coordonnées avec ses arguments.
On remarque que l’objet Point que l’on initialise s’envoie lui-même
un message moveTo. Dans ce cas, le receveur peut être omis ou bien
Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
© Techniques de l’Ingénieur, traité Informatique
LANGAGE JAVA
remplacé par le mot clef this. C’est un cas particulier de la syntaxe
générale de l’envoi de message.
L’initialisation d’un objet.
Le choix du constructeur pour l’initialisation se fait d’après les
arguments que l’on donne au moment de la création de l’objet. Une
création par l’appel p = new Point() utilisera le constructeur sans
argument s’il existe ou aucun sinon. L’appel p = new Point(23,
46) utilisera le constructeur à deux arguments entiers. Types et
nombre des arguments déterminent le constructeur exécuté.
Ramasse-miettes et destruction d’objet.
Nous avons vu comment créer des objets mais il nous est impos-
sible de les détruire. Si la création des objets est explicite, leur des-
truction est implicite. Il nous suffit de les oublier pour qu’un
programme appelé ramasse-miettes ou encore garbage collector se
charge de récupérer la place allouée pour ces objets. Un objet est
oublié lorsqu’il n’est plus référencé nulle part, ni dans un attribut
d’un objet, ni dans une variable locale d’une méthode en cours
faible priorité. Il est bien connu qu’une source majeure de bogues
dans les programmes provient de désallocations de données mal
faites ou bien oubliées. Le ramasse-miettes, technologie très sophis-
tiquée déjà utilisée dans Lisp, Prolog, SmallTalk et Eiffel, libère le
programmeur de la contrainte de désallocation des données.
Les destructeurs.
Le ramasse-miettes est capable de récupérer la mémoire d’un
objet oublié mais il ne peut réaliser certaines désallocations de res-
fichier ouvert, le ramasse-miettes ne fermera pas le fichier seul. Si la
classe de l’objet déclare une méthode dont l’en-tête est void fina-
lize(), celle-ci sera exécutée avant la destruction de l’objet. C’est
dans cette méthode que le programmeur doit éventuellement libé-
rer des ressources autres que la mémoire.
L’héritage de classe.
La classe telle que nous l’avons définie n’est guère différente d’un
paquetage comme on en trouve en Ada [3]. C’est le mécanisme
déclarer qu’une classe, la sous-classe, hérite d’une autre classe, la
super-classe. La déclaration d’héritage se réalise en faisant suivre le
nom de la sous-classe par le mot clef extends et le nom de la super-
classe (cf. figure 3). Une fois l’héritage déclaré, les attributs et les
méthodes de la super-classe sont hérités dans la sous-classe
comme si ils y avaient été définis. Il est alors possible d’opérer de
plusieurs manières non exclusives :
— il est possible d’enrichir la sous-classe avec de nouveaux attri-
buts et de nouvelles méthodes. La figure 3 montre une classe
DrawablePoint héritant de la classe Point et l’enrichissant avec
un attribut color et un constructeur. Notons dans ce fichier l’impor-
tation des classes prédéfinies du paquetage java.awt sur laquelle
nous reviendrons plus tard. Ce paquetage définit la classe Color ;
— il est possible de redéfinir une méthode héritée. On donne
alors dans la sous-classe une définition d’une méthode ayant la
même en-tête que celle que l’on désire redéfinir ;
— il est possible de masquer une variable en en donnant une
nouvelle définition. Le masquage d’une variable n’est pas définitif,
on peut la préfixer par le nom de la classe où elle a été précédem-
ment introduite pour accéder aux définitions dans les super-classes.
La classe DrawablePoint peut à son tour donner naissance à un
nombre quelconque de sous-classes : l’héritage n’a de limites ni en
profondeur ni en largeur. Une classe pour laquelle on ne précise pas
de super-classe, comme la classe Point de la figure 2, hérite impli-
citement de la classe Object. En fait, toute classe hérite directement
ou indirectement d’Object. La classe Object est une classe qui
contient des méthodes générales de recopie, de test d’égalité, etc.
Chaînage des constructeurs.
Notons dans le constructeur de la classe DrawablePoint de la
figure 3 l’appel super(ix,iy). Ce type d’appel doit toujours être la
première instruction du constructeur d’une sous-classe et fait réfé-
H 3 088 − 3
LANGAGE JAVA ________________________________________________________________________________________________________________________
import java.awt.* ;
public class DrawablePoint extends Point {
private Color color ; // la couleur du point
// un constructeur
public DrawablePoint(int ix, int iy, Color ic) {
super(ix,iy) ;
pointColor = ic ;
}
} sance commune de ces méthodes. Une même classe peut implé-
Figure 3 – La classe DrawablePoint
rence au constructeur de la super-classe. Si cet appel n’existait pas,
le compilateur rajouterait implicitement l’appel super() au cons-
tructeur sans argument de la super-classe.
Héritage et typage.
Nous avons à présent deux classes, Point et DrawablePoint qui
hérite de Point. Cela signifie que tout objet instance de la classe
DrawablePoint est aussi un objet de la classe Point. Ainsi, une
variable de type Point peut contenir une référence sur une instance
de la classe Point mais aussi une référence sur une instance de
n’importe quelle sous-classe de Point, en particulier Drawable-
Point.
Redéfinition et liaison dynamique.
L’un des points forts de la programmation orientée objet est la
liaison dynamique des méthodes. Supposons que la classe Point
ait une méthode writeText qui affiche sous forme de texte les
coordonnées du point. Nous redéfinirons cette méthode dans la
classe DrawablePoint pour qu’elle affiche aussi la couleur. Suppo-
sons une variable p de type Point. Nous avons vu que cette variable
peut contenir une référence sur une instance de la classe Point ou
bien sur une instance de la classe DrawablePoint. Comment doit
alors être compilé un appel de méthode p.writeText() ? Le pro-
blème est que si p référence une instance de la classe Point, il faut
exécuter la méthode writeText de la classe Point alors que si p
référence une instance de la classe DrawablePoint, c’est la
méthode writeText de la classe DrawablePoint qu’il faut exécu-
ter. Le compilateur n’a statiquement aucun moyen de déterminer
quel objet sera référencé par la variable p. Il n’a d’autre choix que de
programmer une recherche dynamique de la méthode à exécuter à
partir de l’objet référencé par p au moment de l’exécution de l’appel.
Signalons que ce type de recherche n’est nécessaire que dans des
cas comme celui-ci et qu’il est néanmoins très efficace. À tel point
que les langages SmallTalk et Eiffel [15] l’utilisent exclusivement
même quand ce n’est pas obligatoire.
Polymorphisme.
La recherche dynamique de la méthode à exécuter est l’une des
forces de la programmation orientée objet puisqu’elle permet une
bonne modularité et une bonne répartition du code dans les classes.
C’est elle qui nous dispense des grosses procédures de traitement
par cas selon la nature de l’argument employé. La faculté de décla-
rer et de mettre en œuvre des méthodes de signatures identiques
dans des classes différentes ne se limite pas aux classes et leurs
sous-classes. On parle alors de polymorphisme. On pourrait ainsi
définir la méthode moveTo(x,y) dans d’autres classes que les clas-
ses Point et DrawablePoint, par exemple une classe Circle. Le
problème est alors de savoir comment manipuler des objets aussi
différents à l’aide d’une même variable ou, plus précisément, quel
type donner à cette variable. Notons que ce problème n’existe pas
Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
H 3 088 − 4 © Techniques de l’Ingénieur, traité Informatique
en Smalltalk [9] où le typage est purement dynamique, c’est-à-dire
où seuls les objets sont typés, pas les variables.
On pourrait déclarer la variable de type Object, mais alors la
méthode moveTo(x,y) devrait être définie dans cette classe, alors
qu’il n’y a pas forcément de sens à déplacer n’importe quel objet.
Pour donner un sur-type à un ensemble de classes, Java utilise la
notion d’interface.
Interfaces.
Une interface se déclare comme une classe mais en mettant le
mot clef interface à la place du mot clef class. Une classe
n’hérite pas d’une interface, elle la met en œuvre, ou l’implémente.
L’interface n’est qu’une déclaration de signatures de méthodes et
toutes les classes implémentant cette interface auront une connais-
menter plusieurs interfaces. L’en-tête d’une classe sous sa forme
générale est :
public class A extends B implements I1, ..., In {
... }
Une interface peut être utilisée à la place d’une classe dans la
déclaration de type d’une variable à la condition que les seuls mes-
sages envoyés à l’objet que la variable référence correspondent à
des méthodes déclarées dans l’interface. Par exemple, avec les
déclarations de la figure 4, les instructions suivantes sont valides :
Mobile m ;
m = new Point() ;
m.moveTo (100,100) ;
m = new Circle() ;
m.moveTo(50,50) ;
Les interfaces sont un moyen de donner un sur-type commun à
un ensemble de classes qui n’ont pas de relations d’héritage entre
elles.
Héritage simple et héritage multiple.
L’héritage en Java est simple. Cela signifie qu’une classe ne peut
hériter que d’une seule autre classe. Il en est ainsi en SmallTalk.
Cependant C++ et Eiffel ont adopté l’héritage multiple : dans ces
deux langages, une classe peut hériter de plusieurs autres classes.
L’argumentation en faveur de l’héritage simple est qu’il est beau-
coup plus facile à appréhender que l’héritage multiple et qu’il ne
pose pas de problèmes sémantiques comme celui de savoir quelle
méthode exécuter lorsque deux méthodes de même en-tête sont
héritées dans une classe. La technologie Eiffel est là pour montrer
que, bien appréhendé et en utilisant des ressources programma-
tiques bien conçues comme les clauses d’adaptation d’héritage
d’Eiffel, l’héritage multiple se révèle simple d’utilisation, sans
aucune ambiguïté et tellement plus puissant. S’il est vrai que l’on
peut se passer de l’héritage multiple dans la modélisation des pro-
blèmes et dans la programmation, il est appréciable de pouvoir l’uti-
liser. En Java, les interfaces permettent de contourner le problème,
au prix de redéfinitions de méthodes.
Variables et méthodes de classes.
En faisant précéder des déclarations de variables ou de méthodes
par le mot clef static, on déclare des variables et des méthodes de
classe. Cela signifie que ces variables et méthodes appartiennent à
la classe et non aux objets. Ce n’est plus un objet qui les exécute. On
les référence en utilisant la notation pointée avec le nom de la
classe plutôt qu’un objet. Ainsi dans la figure 2, l’appel
Math.sqrt(x*x+y*y) dans la méthode distOrigin correspond à
l’appel d’une méthode de classe. En effet Math est le nom d’une
classe fournissant des outils mathématiques et sqrt est une
méthode de classe de la classe Math. Programmer uniquement avec
des méthodes de classe revient à programmer classiquement. En
effet, une classe contenant des méthodes de classes apparaît
comme un paquetage de procédures et de fonctions impératives
classiques qu’il suffit de préfixer par le nom de la classe pour les
exécuter.
_______________________________________________________________________________________________________________________ LANGAGE JAVA

par défaut lorsqu’aucun mot clef n’est utilisé. Le tableau 1 décrit

// DŽclaration d'une interface. sommairement ces quatre modes.
Nota : en Ada [3], c’est la notion de paquetage avec ses deux composantes : l’une
public interface Mobile { déclarative à l’intention de l’utilisateur qui ne contient que des en-têtes et de la documen-
tation, l’autre à l’usage du programmeur qui met en œuvre le paquetage et qui contient le
public void moveTo(int nx, int ny); code effectif. Eiffel et son environnement [16] proposent de nombreux outils syntaxiques
} pour décrire la visibilité des composantes d’une classe mais aussi et surtout différents
modes de visualisation d’une classe dont un qui permet de ne voir que les composantes
accessibles avec leurs en-têtes, leurs commentaires et leurs conditions d’utilisation sous la
// DŽclaration de la class Point implŽmentant l'interface
forme de pré et postconditions.

public class Point implements Mobile { Par exemple, avec la déclaration de la figure 2, seules les métho-
des de la classe Point peuvent utiliser nommément les attributs x
private int x,y ; // les coordonnŽes du point et y alors qu’un message moveTo(nx,ny) peut être envoyé par
n’importe quel objet.
...

public void moveTo(int nx, int ny) {

x = nx ; Tableau 1 – Les modes de visibilité

y = ny Mode par Mode Mode Mode
Visibilité
défaut public protégé privé
}
} Visible par les sous-classes oui oui oui non
du même paquetage
// DŽclaration de la classe Circle implŽmentant aussi l'interface Visible par les sous-classes non oui oui non
d’un autre paquetage
public class Circle implements Mobile {
Visible par les non-sous- oui oui oui non
private Point centre ; // centre et rayon du cercle private classes du même
paquetage
int radius ;
Visible par les non-sous- non oui non non
public Circle() { classes d’un autre
paquetage
radius = 20 ;
centre = new Point() ;
} Classes abstraites.
Presque tous les langages orientés objets proposent la notion de
public void moveTo(int nx, int ny) { classe abstraite. Une classe est déclarée abstraite, mot clef abs-
centre.moveTo(nx, ny); tract, dès lors que l’une de ses méthodes est elle-même abstraite.
Une méthode abstraite est une méthode dont on ne déclare que
}
l’en-tête et dont on ne donne pas la mise en œuvre. Les méthodes
} abstraites sont héritées par les sous-classes. Si la sous-classe ne
donne pas une mise en œuvre de la méthode abstraite, elle doit elle-
Figure 4 – L’interface Mobile même être déclarée abstraite. Les classes abstraites ne peuvent pas
avoir d’instances car il leur manque des éléments de mise en œuvre.
Utilisation des classes abstraites.
Constantes, méthodes et classes finalisées. L’utilité des classes abstraites est fort bien décrite dans de nom-
Java se veut un langage sécurisé et il est vrai que beaucoup de breux ouvrages [4], [15]. Un exemple de classe abstraite est la classe
protections sont mises en place. L’une d’elles consiste à empêcher la Textable de la figure 5. Cette classe décrit deux méthodes d’affi-
redéfinition de méthodes ou le changement de valeurs de variables chage textuel d’un objet. La première, writeText() est abstraite
d’instances en les déclarant finalisées à l’aide du mot clef final. car elle dépend des particularités de l’objet. La deuxième,
Une variable de classe finalisée et initialisée est une constante de writeTextN1() écrit une représentation textuelle de l’objet par un
classe. On peut également empêcher les programmeurs d’étendre appel à writeText() puis affiche un saut de ligne. Pour que
une classe donnée à l’aide du qualificatif final : aucune classe ne writeTextN1() puisse appeler writeText(), il faut que celle-ci
peut hériter d’une classe finalisée. Cela permet d’éviter des utilisa- soit déclarée. Dans cette classe, c’est une méthode abstraite. Puis,
tions perverses de certaines classes, en particulier parmi celles four- toutes les sous-classes qui hériteront de la classe Textable devront
nies par l’environnement Java. Cela permet aussi d’optimiser la mettre en œuvre la méthode writeText() à leurs manières particu-
compilation des appels de méthodes de cette classe puisqu’on sait lières mais elles hériteront toutes de la méthode writeTextN1().
qu’elles ne seront pas redéfinies et qu’on peut se passer de la liaison Ici aussi, on comprend que la recherche de la méthode write-
dynamique de méthodes. Text() doit être dynamique.
Encapsulation des données et des programmes. Retour sur les interfaces.
Un credo du Génie logiciel est la nécessité de masquer tout ou Une interface peut être vue comme une classe complètement abs-
partie des informations qui ne sont pas strictement nécessaires à traite. Les interfaces peuvent néanmoins contenir des déclarations
l’utilisation d’un sous-programme par un autre programmeur. Les de constantes. Les constantes sont des attributs déclarés statiques,
avantages en sont bien connus avec, en particulier, la possibilité de mot clef static et finalisés, mot clef final.
mettre en œuvre différemment ce sous-programme sans que son Les paquetages.
utilisateur ne soit pénalisé.
Afin d’éviter les collisions de noms en cas de réutilisation de code,
Java propose quatre modes de visibilité des composantes : le les classes sont regroupées en paquetages. Les paquetages sont
mode public avec le mot clef public, le mode protégé avec le mot appelés des clusters en Eiffel. Un paquetage est le regroupement
clef protected, le mode privé avec le mot clef private et le mode logique et physique d’un certain nombre de classes dans un réper-

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
© Techniques de l’Ingénieur, traité Informatique H 3 088 − 5
LANGAGE JAVA ________________________________________________________________________________________________________________________
public abstract class Textable {
public abstract void writeText() ;
public void writeTextNl() {
writeText() ;
System.out.println() ;
} t.start() ;
} }
Figure 5 – La classe abstraite Textable
public interface Runnable {
public abstract void run() ;
} Figure 7 – Un lancement de processus léger
Figure 6 – L’interface Runnable
toire. Ces classes doivent bien entendu former un tout à peu près
autosuffisant. De fait, le nom complet d’une classe est composé du
nom du paquetage, suivi d’un point et du nom de la classe. Le nom
complet n’est utilisé que pour désigner les classes définies dans un
autre paquetage que celui où elles sont employées. Cependant,
grâce à des déclarations import comme celle de la figure 3, il est
possible d’indiquer les paquetages dans lesquels le compilateur doit
rechercher une classe utilisée et non définie localement.
Structures de contrôle et expressions.
Les structures de contrôle de Java, conditionnelles, boucles, etc.,
sont celles du C ANSI. Les opérateurs sont aussi ceux du C ANSI, les
trois opérateurs concernant les pointeurs, i.e. ->, *, et &, en moins et
deux opérateurs >>> et instanceof(C) en plus. Signalons pour les
programmeurs habitués à C que la sémantique des opérateurs
infixés  et & est modifiée dans le cas où les opérandes des données
sont de type boolean.
Les processus légers.
Java propose la notion très intéressante de thread, c’est-à-dire de
processus légers. Les processus légers sont des flots de contrôle
distincts qui s’exécutent en parallèle dans un même programme. Ils
partagent leurs données. Java propose des outils de synchronisa-
tion de type wait(), la thread s’endort, et notify() qui réveille une
thread endormie. Enfin des outils d’exclusion mutuelle, mot clef
synchronized, permettent de poser des verrous sur un objet pour
en interdire l’accès à d’autres threads. L’exécution concurrente des
flots de contrôle est réalisée en fonction des niveaux de priorité des
threads que le programmeur peut fixer. Les threads les plus priori-
taires sont exécutées prioritairement jusqu’à ce qu’elles décident de
passer la main à l’aide d’une instruction wait() ou de l’appel de la
méthode de classe Thread.yield(). C’est quand même au pro-
grammeur de gérer la concurrence en cas de processus ayant des
priorités distinctes. Dans le cas le plus courant de priorités identi-
ques, il n’a en général pas à intervenir.
Le petit schéma que nous allons présenter montre l’utilisation des
interfaces pour la création d’une thread. Pour pouvoir créer une
thread, il faut implémenter l’interface Runnable (cf. figure 6). Implé-
menter Runnable oblige juste à avoir une méthode run().
Pour lancer une thread, il faut un objet d’une classe implémentant
Runnable, la classe MyThread (figure 7), et qui crée un objet de la
classe Thread en se donnant lui-même en paramètre à l’aide du mot
clef this qui désigne l’objet lui-même. En envoyant le message
start à l’objet de type Thread, celui-ci lance l’exécution de la
méthode run() de l’instance de MyThread, dans un flot de contrôle
séparé.
Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
H 3 088 − 6 © Techniques de l’Ingénieur, traité Informatique
public class MyThread implements Runnable {
public void startThread() {
// crŽation de la thread
Thread t ;
t = new Thread(this) ;
public void run() {
// code ˆ exŽcuter dans la thread
...
}
}
La généricité.
Une classe générique est une classe paramétrée par une ou plu-
sieurs autre(s) classe(s). L’exemple le plus commun pourrait être
Stack[T] décrivant des piles d’objets de type T où T paramètre
générique n’est pas spécifié. En effet, les opérations sur une pile
ne dépendent pas du type des objets de la pile. Il est ensuite
possible d’utiliser Stack[Point] pour une pile de points ou
Stack[FloatNumber] pour une pile de nombres flottants. Java ne
propose pas les types génériques.
Les exceptions.
Pour gérer les erreurs et les situations exceptionnelles, Java
propose un mécanisme d’exception inspiré de C++. La structure de
contrôle try permet de lancer l’exécution d’un bloc d’instructions
tout en proposant des traitements d’exceptions dans des blocs
catch suivant le bloc try. L’exécution du bloc d’instructions peut
déclencher une exception explicite à l’aide d’une instruction throw.
Le programme est alors interrompu et l’exception, qui est un objet
particulier, est propagée. Les traitements d’exceptions vérifient s’ils
ont prévu un traitement de ce type d’exception. Si oui, le traitement
du bloc catch correspondant est exécuté. La structure try peut
également comprendre un bloc d’instructions, mot clef finally,
qui sera exécuté qu’il y ait ou non une exception de déclenchée. La
programmation et la gestion des situations exceptionnelles par les
exceptions sont maintenant bien connues.
La machine virtuelle.
Le résultat de la compilation d’un programme Java est un code
abstrait, le bytecode, conçu pour un processeur abstrait [14]. Pour
exécuter ce bytecode, il faut un programme spécialisé, la machine
virtuelle, qui émule le processeur abstrait. Ainsi un programme Java
est indépendant de la plate-forme, de l’architecture et du système
d’exploitation, dès lors qu’il existe une machine virtuelle sur cette
plate-forme. Le défaut de ce genre de technique réside dans la perte
de performances due à l’émulation du processeur abstrait. Dans [5],
nous aborderons les problèmes de la portabilité réelle de Java et de
l’impact de la technologie machine virtuelle sur les performances de
ce langage.
Les applets.
Les applets, appliquettes en français, sont des applications desti-
nées à être exécutées dans les navigateurs Web. Les principaux
navigateurs Web ont incorporé une machine virtuelle qui leur per-
met d’exécuter le code compilé Java. Nous y reviendrons aux para-
graphes 2 et 3.
L’édition de lien dynamique.
La classe ClassLoader du paquetage fourni java.lang permet
de charger dynamiquement des classes. Ces classes peuvent même
être téléchargées à travers le réseau Internet si elles proviennent
_______________________________________________________________________________________________________________________
d’un serveur accédé par le Web. Java propose donc, et c’est relative-
ment unique, des outils de chargements et d’éditions de lien dyna-
miques. Les navigateurs Web se servent de la classe ClassLoader
pour réaliser des téléchargements de classes sécurisées (cf. § 3).
1.2 Conclusions
Java est un langage plaisant qui a fait le choix de la sécurité plutôt
que celui des fonctionnalités à tout prix. On peut se féliciter de la
suppression des pointeurs remplacés par des références. Certains
déplorent l’absence de pointeurs sur fonction comme il en existe en
C++, mais la technologie objet permet sans aucun travail supplé-
mentaire de s’en passer, grâce à une conception véritablement
orientée objet : on peut réifier les traitements en en faisant des
objets que l’on passe en paramètres [4], [15].
On peut, en revanche, regretter l’absence d’héritage multiple. La
méthode des interfaces compense cela mais elle est beaucoup
moins naturelle que l’héritage multiple. Si l’héritage multiple a la
C++ peut sembler regrettable en raison des confusions et des
bogues qu’il apporte, les concepteurs de Java auraient pu s’inspirer
des travaux de B. Meyer sur Eiffel.
Même si les aspects sécurité sont cruciaux pour l’utilisation atten-
due de Java, ils induisent des limitations qui peuvent sembler
excessives. Beaucoup de classes importantes des paquetages four-
nis avec Java sont finalisées et donc non extensibles. De plus, le lan-
gage est très limité du point de vue de l’interopérabilité et des accès
aux systèmes d’exploitation. Cela est justifié par la prévision de
machines entièrement Java. C’est aussi l’origine du procès entre
Microsoft et Sun Microsystems puisque la machine virtuelle du
navigateur Microsoft Explorer intègre des fonctionnalités d’accès au
système d’exploitation sous-jacent qui n’entrent pas dans la norme
Java de Sun Microsystems [20].
2. Les paquetages Java
Un ensemble riche de classes regroupées par domaines dans dif-
férents paquetages est fourni d’origine avec Java. Cette standardi-
sation de fait de nombreuses classes devrait permettre d’éviter les
problèmes rencontrés avec C++, où chaque éditeur de compilateur a
développé ses propres classes, rendant difficile la recompilation
d’un programme source C++ dans un environnement de développe-
ment différent de celui d’origine. La grande variété des classes pro-
posées dans les paquetages Java permet une programmation facile
et rapide d’applications complexes. Dans cette section, nous don-
nons un bref aperçu de ce dont on dispose.
2.1 Le paquetage java.lang
Le paquetage java.lang contient les classes de base de Java :
Object, String, Math, Thread, etc. La directive d’importation
import java.lang.* ; est implicite.
2.2 Les paquetages utilitaires
D’autres classes d’intérêt général comme Date, Random, Vector
ou Stack sont définies dans java.util. Le paquetage java.math
ne contient que les deux classes BigDecimal et BigInteger per-
mettant de manipuler de très grands nombres sans perte de préci-
Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
© Techniques de l’Ingénieur, traité Informatique
LANGAGE JAVA
sion. Enfin le paquetage java.text permet le formatage des dates,
des heures et des nombres suivant les conventions de chaque pays.
Java utilise le standard Unicode établi par le Unicode Consortium
pour le codage des caractères. Ce codage est réputé pourvoir sup-
porter l’échange, le traitement et l’affichage de textes écrits dans dif-
férentes langues.
2.3 Le paquetage java.applet
Le paquetage java.applet permet d’écrire des applets, ces
petits programmes que peuvent exécuter les navigateurs Web.
L’applet est une classe héritant de la classe java.applet.Applet.
C’est un programme d’interface dont l’affichage est réalisé à l’inté-
rieur du navigateur Web, au sein d’une page HTML. L’utilisateur
peut redéfinir des méthodes comme init(), initialisation des res-
sources de l’applet, ou paint(), dessin de l’interface de l’applet. Il
peut aussi définir simplement les réactions de l’interface aux actions
de l’utilisateur : gestion des événements liés aux mouvements et
clicks de la souris, saisie au clavier, changement de focus, ouverture
et fermeture des fenêtres, etc.
L’ouvrage de Flanagan [8] montre la puissance et la concision de
Java pour l’écriture de telles applications interactives. Ce qui est
remarquable, c’est que si l’on ne cherche pas à trop personnaliser
ses interfaces et si l’on accepte des présentations à peu près stan-
dardisées, il est très rapide d’écrire des applets. La figure 8 montre
une applet permettant à l’utilisateur de dessiner librement avec la
souris. Elle est inspirée de [8] (chapitre 4, page 102). Pour être char-
gée dans un navigateur Web, il suffit de mettre les lignes suivantes
dans un fichier HTML :
<APPLET code=ÓDessin.ClassÓ
width=300
height=200>
</APPLET>
2.4 Le paquetage java.awt
et les paquetages dérivés
Ce paquetage est celui qui permet de construire des interfaces
graphiques. Classiquement, on crée des conteneurs, classe
Container et ses sous-classes, dans lesquels on dispose des com-
posants appelés les widgets, classe Component et ses sous-classes,
à l’aide d’instructions de répartition du type « en haut au centre ».
Ce placement des widgets grâce à un gestionnaire de répartition,
classe implémentant l’interface Layout.Manager, est beaucoup
plus pratique que le placement par coordonnées. Les interfaces gra-
phiques ainsi construites peuvent être exécutées par un navigateur
Web ou indépendamment de tout navigateur.
La programmation des réponses aux événements quand l’utilisa-
teur interagit avec les widgets est relativement classique et donc
assez lourde. Le paquetage java.awt.event lui est dédié.
Le paquetage java.awt.datatransfer contient les classes per-
mettant de gérer le presse-papiers : opérations couper, copier, coller.
java.awt.image se charge des animations et traitements
d’images.
2.5 Les paquetages java.io et java.net
Le paquetage java.io permet de réaliser classiquement des pro-
cédures d’entrée-sortie sur console ou sur fichiers. Notons qu’il per-
met également de définir des tubes, les pipes d’Unix, pour la
H 3 088 − 7
LANGAGE JAVA ________________________________________________________________________________________________________________________

import java.applet.* ;
import java.awt.* ;
import java.awt.event.* ;

public class Dessin extends Applet {

protected int x_origin = 0 ; // coordonnŽes de l'origine pour
protected int y_origin = 0 ; // tracer des traits

public Dessin() { // procedure d'initialisation

addMouseListener(new DMouseListener()) ;
addMouseMotionListener(newDMouseMotionListener()) ;
}

// Les classes de rŽponse aux ŽvŽnements dus ˆ la souris.

// Ces classes sont dŽfinies ˆ l'interieur de la classe
// Dessin, ce sont des "inner class". Elles auraient pu
// •tre dŽfinies ˆ l'extŽrieur

private class DMouseListener extends MouseAdapter {

// AppelŽe quand l'utilisateur enfonce le bouton de la souris,
// elle mŽmorise les coordonnŽes de l'origine
public void mousePressed(MouseEvent e) {
x_origin = e.getX() ;
y_origin = e.getY() ;
}
}

private class DMouseMotionListener extends MouseMotionAdapter {

// AppelŽe quand l'utilisateur bouge la souris avec bouton
// enfoncŽ, trace des traits partiels.

public void mouseDragged(MouseEvent e) {

Graphics g = getGraphics() ;
g.drawLine(x_origin,y_origin,e.getX(),e.getY()) ;
x_origin = e.getX() ;
y_origin = e.getY() ;
}
}
}

Figure 8 – Une applet de dessin en Java 1.1

communication entre threads. Dans java.util.zip, on trouve les
outils nécessaires à la création et l’utilisation de fichiers compres-
sés.
Avec le paquetage java.net, nous entrons dans un des aspects
le plus intéressant et le plus original du langage Java : la program-
mation en réseau. En matière de programmation du Web, il est pos-
sible d’analyser une information à partir d’une URL, c’est-à-dire à
partir de son adresse, pour en connaître le type et diverses autres
informations. Il est également possible de télécharger cette URL. Ce
paquetage permet aussi d’établir assez simplement des communi-
cations entre machines distantes reliées par réseau à l’aide de soc-
kets via le protocole TCP/IP.
2.6 Le paquetage java.rmi
et les paquetages associés
Les paquetages java.rmi, java.rmi.dgc, java.rmi.registry
et java.rmi.server sont dédiés à l’invocation de méthodes à dis-
tance : Remote Method Invocation ou RMI. Il s’agit d’un mécanisme
qui permet à un programme Java d’appeler certaines méthodes
d’un objet s’exécutant dans une autre machine virtuelle Java, le plus
souvent sur un serveur distant. L’établissement de la connexion et le
transfert des arguments et de la valeur de retour du message sont
entièrement pris en charge par les différentes classes des paque-
tages RMI [10].

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
H 3 088 − 8 © Techniques de l’Ingénieur, traité Informatique
_______________________________________________________________________________________________________________________
2.7 Le paquetage java.sql
Le paquetage java.sql est dédié à JDBC, Java DataBase
Connectivity, une interface standard d’accès aux bases de données
SQL. Elle permet de se connecter et d’interroger toute base de don-
nées relationnelle possédant un driver JDBC ou ODBC, puisque le
pont JDBC-ODBC est fourni d’origine.
2.8 Le paquetage java.beans
Ce paquetage java.beans est dédié à l’architecture de compo-
sants logiciels JavaBeans. Elle permet de transformer une classe en
composant autosuffisant et réutilisable, manipulable et paramétra-
ble dans un environnement de développement graphique, où les
applications sont construites par assemblage graphique de tels
composants. Ceux-ci sont constitués de propriétés, les attributs,
proposent des services, les méthodes. Ils signalent des événements,
comme le changement de la valeur d’une propriété.
2.9 Le paquetage java.lang.reflect
Ce paquetage est consacré à la méta-programmation. Il offre les
moyens de connaître dynamiquement les attributs et les méthodes
d’une classe chargée, pour envoyer par exemple un message cons-
truit dynamiquement à un objet.
2.10 Le paquetage java.security
et les paquetages associés
Les paquetages java.security, java.security.acl et
java.security.interfaces sont dédiés à la sécurité des pro-
grammes Java et, notamment, aux applets signées, sujet du para-
graphe 3.
2.11 Conclusions
Les paquetages Java sont la force de Java. Quel programmeur n’a
rêvé par exemple de pouvoir programmer simplement des inter-
faces graphiques ou des programmes répartis. Ces paquetages le
permettent. Des 8 paquetages de la version 1.0 de Java, on est passé
à 22 dans la version 1.1. De nouvelles possibilités sont déjà propo-
sées pour la version 1.2, en béta test au moment où nous écrivons.
Parmi celles-ci, citons notamment une refonte des composants gra-
phiques, la gestion du glisser-déposer et un ensemble de classes
collections plus évoluées.
3. Java et la sécurité
Les programmes Java sont destinés à être téléchargés à travers le
réseau, ce qui implique des aspects sécuritaires. Nul n’oserait exé-
cuter un code téléchargé dont il ignore le contenu réel s’il ne dispose
d’éléments quant à la sûreté du code. La sécurité est assurée à plu-
sieurs niveaux et concerne principalement les applets.
Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
© Techniques de l’Ingénieur, traité Informatique
LANGAGE JAVA
3.1 Les restrictions par le langage
Le premier niveau de sécurité est celui du langage lui-même. Java
a remplacé les pointeurs par des références. Il n’y a pas d’arithmé-
tique des références en Java similaire à l’arithmétique des pointeurs
de C ou de C++. Il est donc impossible au programmeur de manipu-
ler des adresses mémoires pour accéder à des zones non autorisées.
La possibilité de déclarer une classe ou des méthodes finales
interdit tout héritage de la classe et toute redéfinition des méthodes.
Cela interdit à un programmeur mal intentionné de détourner ces
classes et ces méthodes de leurs objectifs initiaux.
3.2 L’analyse du bytecode
Rien n’empêche un programmeur bien avisé de la machine vir-
tuelle de produire un bytecode véreux, ne respectant pas les restric-
tions sur le langage énumérées dans le paragraphe 3.1. Rien
n’empêche un bon informaticien de concevoir un compilateur ne
respectant pas les restrictions sur le langage et produisant néan-
moins des fichiers d’instructions pour la machine virtuelle de Java.
C’est pourquoi le chargement des classes suspectes, c’est-à-dire cel-
les importées à travers le réseau, s’accompagne d’une vérification
du code pour la machine virtuelle. C’est de la responsabilité de votre
environnement d’exécution, en général un navigateur Web, de véri-
fier la qualité du bytecode pour la machine virtuelle. On s’assure
bien entendu que le code est bien un code pour la machine virtuelle
Java. On vérifie aussi que l’exécution se passera sans débordement
de la pile d’exécution, que les registres de la machine virtuelle ne
sont pas utilisés à mauvais escient, bref que le code qui sera exécuté
n’a aucune chance de mettre à mal la machine virtuelle.
3.3 La maîtrise du chargement des classes
C’est l’une des sous-classes de la classe abstraite
java.lang.ClassLoader qui est responsable du chargement
dynamique des classes. Le chargement des classes fait une distinc-
tion entre les classes locales et les classes téléchargées. Les classes
locales, qu’elles proviennent des bibliothèques du langage Java ou
qu’elles soient propriétés de l’utilisateur, sont considérées comme
fiables. Elles sont chargées dans un espace d’adressage différent de
celui des classes téléchargées qui sont considérées comme non fia-
bles. On empêche ainsi la substitution d’une classe téléchargée à
une classe locale et donc le remplacement des classes fondamenta-
les des bibliothèques par des classes douteuses.
3.4 Les restrictions sur les applets
Les environnements d’exécution des applets, c’est-à-dire les navi-
gateurs Web, sont chargés de mettre en œuvre des restrictions sur
ce que les applets sont autorisées à faire dans votre environnement.
Ces restrictions concernent, par exemple, les accès à vos systèmes
de fichiers. Il est interdit d’ouvrir des fichiers en lecture ou en écri-
ture, d’analyser des répertoires, de détruire ou renommer des
fichiers, de vérifier l’existence d’un fichier, etc.
Les restrictions concernent aussi les accès réseaux, qui sont éga-
lement interdits sauf vers le site d’où provient l’applet téléchargée.
Les applets ne doivent pas pouvoir créer d’objets fondamentaux,
comme des dérivés de la classe java.lang.ClassLoader. Elles ne
peuvent exécuter que des méthodes Java, les appels à des DLL écri-
H 3 088 − 9
LANGAGE JAVA ________________________________________________________________________________________________________________________
tes dans d’autres langages étant interdits. Les navigateurs offrent
souvent la possibilité d’inhiber les restrictions.
Pour les applications Java qui ne sont pas des applets, il n’y a
aucune restriction a priori. Il est possible alors de définir ses propres
règles, en créant une sous-classe de la classe abstraite Security-
Manager et en l’associant à l’application par la méthode de classe
System.setSecurityManager.
On peut imaginer bien d’autres restrictions, mais il faut garder à
l’esprit que c’est le navigateur, et lui seul, qui est libre de les mettre
en œuvre. En particulier, on ne connaît pas de navigateur restrei-
gnant la surconsommation de mémoire ou de CPU.
3.5 Les applets signées
Les restrictions imposées aux applets sont, dans la pratique, sou-
vent trop contraignantes. Depuis la version 1.1, Java introduit la
notion d’applets signées pour lesquelles les restrictions sont levées.
Il s’agit d’applets téléchargées dont le code est accompagné d’un
certificat garantissant son origine et sécurisé par un système de
cryptage pour garantir la sûreté du transfert.
3.6 Conclusions
Tout a été pensé et mis en œuvre pour assurer la sécurité des
environnements exécutant des applets téléchargées. Cependant, les
informaticiens sont bien placés pour savoir que le risque zéro
n’existe pas.
4. Mythes et réalités
Cette présentation avait pour but de montrer l’essence de Java, ce
qu’on peut en attendre et comment y accéder. Nous pouvons à pré-
sent faire le point sur les différentes qualités que l’on prête à ce lan-
gage.
Un langage orienté objet.
Java est un langage orienté objet, mais il ne propose pas tout ce
que l’on peut attendre d’un langage de ce type. En un sens, les puris-
tes de l’objet peuvent être déçus, mais le langage est suffisamment
simple pour que le programmeur peu au fait de la technologie objet
puisse s’y investir et maîtriser le langage rapidement. Seule les
notions de redéfinitions et de liaison dynamique des méthodes peu-
vent demander un certain apprentissage. La syntaxe très proche de
celle de C ou de C++ est un autre facteur facilitant la prise en main
du langage. Mais attention, cette proximité de syntaxe ne traduit pas
une proximité des sémantiques. Java est très éloigné de C++.
Un langage plus propre.
Un aspect important pour les théoriciens de la programmation et
des langages est le toilettage du langage. Le langage est plus simple
et plus propre que C++ avec, notamment, la suppression des poin-
teurs déjà préconisée par SmallTalk et Eiffel. De même, l’héritage
simple apporte aussi une simplification de la sémantique du lan-
gage même si celle-ci se paie par une complexification de la pro-
grammation. Le programmeur est libéré de la gestion de la mémoire
grâce au ramasse-miettes qui le dispense des trop fameux problè-
mes d’allocation et désallocation de mémoire propres aux langages
de moins haut niveau. Le programmeur alloue en créant des objets
mais il n’a jamais la charge de la récupération de la mémoire non
utilisée. Cela peut être déroutant pour les habitués de C et de C++
mais on s’y fait très bien au point de ne plus pouvoir revenir en
Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie est strictement interdite.
H 3 088 − 10 © Techniques de l’Ingénieur, traité Informatique
arrière car l’on perd le réflexe d’envisager soi-même la gestion de la
mémoire.
Un langage efficace et portable.
Le problème de l’efficacité réelle de Java sera abordé plus profon-
dément dans [5]. La mise en œuvre de Java est présentée comme
novatrice alors que le concept de machine virtuelle était déjà forma-
lisé par L. Nolin, un des pères de l’informatique française, en 1969
[19]. Il a d’ailleurs largement été utilisé dans le passé. Même s’il
apporte des avantages non négligeables dans le domaine de la por-
tabilité en libérant l’exécutable du système d’exploitation et de
l’architecture matérielle, il n’en reste pas moins que la perte
d’efficacité est sensible. Sans cette technique, il n’aurait pas été
envisageable de télécharger du code dans les navigateurs Web,
mais Java est en moyenne vingt fois plus lent qu’un code C++ équi-
valent [8]. On peut cependant arguer que, dans son domaine
d’application privilégié, c’est-à-dire les interfaces et la programma-
tion répartie, le problème des performances est moins crucial que
celui des fonctionnalités.
Nous pouvons aussi mentionner les compilateurs JIT, compila-
teurs Just In Time aussi appelés compilateurs à la volée que nous
verrons dans [5].
Les facilités d’un langage de prototypage.
On sait l’attrait des langages interprétés (Lisp, Prolog, Basic...)
dans le processus de programmation : une erreur est corrigée
presqu’à la volée et il n’y a pas de temps de compilation et d’édition
de lien. On peut donc reprendre immédiatement l’exécution et les
tests. En Java, les classes sont compilées mais il n’y a pas d’édition
de lien, cette dernière est dynamique. Si une erreur est détectée, on
corrige la classe, on la recompile et on relance l’exécution. Java
combine donc les avantages des langages interprétés et des langa-
ges compilés.
Un langage puissant, simple d’utilisation.
Java est un langage simple d’utilisation car son orientation objet
est réduite au plus simple et sa sémantique est également simple.
Mais c’est surtout les bibliothèques de classes fournies avec le lan-
gage et dont nous avons parlé qui font de Java un langage très
apprécié. Il est très simple d’écrire des interfaces. Il est très simple
d’écrire des applications réparties. Il est très simple d’attaquer Inter-
net depuis Java. C’est une des raisons du succès de Java dans
l’enseignement universitaire : des élèves débutants peuvent se per-
mettre d’écrire des applications impressionnantes. Par ailleurs, les
outils de développement dont nous parlons en Doc H 3 088 sont
assez complets et simples d’utilisation.
Un langage sécurisé.
Nous avons vu au paragraphe 3 toutes les mesures qui ont été
prises pour faire de Java un langage sécurisé protégé aussi bien
contre les maladresses des programmeurs que contre d’éventuelles
mauvaises intentions. Nous pensons que le but est atteint, notam-
ment par le contrôle du bytecode par la machine virtuelle, mais
seule l’expérience nous le montrera. Il n’est pas certain que les pro-
moteurs de Java affichent les failles constatées ou connues du sys-
tème.
Un langage d’avenir.
L’investissement de Sun Microsystems Inc., d’IBM et de Microsoft
a été colossal. Il est suivi de celui de beaucoup d’entreprises de
développement informatique. Les fonctionnalités de Java concer-
nant la programmation du Web sont telles qu’il devient l’outil incon-
tournable pour ce faire. C’est Java qui a donné l’interactivité réelle
aux applications dans les navigateurs Web. Sans Java, ces naviga-
teurs ne sont que de simples afficheurs d’informations et ce n’est
pas suffisant pour des activités de gestion d’une entreprise via
l’Intranet ou des activités de commerces électronique via Internet. Il
est certain que l’on n’écrira pas tout en Java, car certaines applica-
tions ont besoin de beaucoup d’efficacité, mais le domaine d’appli-
cation de Java est très large et ses bibliothèques de classes lui
assurent un intérêt remarquable. Alors, oui ! Java est un langage
d’avenir.
 P
O
U
Langage Java R

E
par Patrick BELLOT
N
Docteur d’État en informatique
Professeur à l’École nationale supérieure des Télécommunications
et Christophe MATIACHOFF
Docteur de l’université Pierre-et-Marie-Curie S
IBM Global Services-CGI Informatique, centre de Compétences Objet
A
Références bibliographiques V
[1] Java : market, opportunities, and trend. Zona
Research Inc (1997).
[8] FLANAGAN (D.). – Java in a nutshell. O’Reilly
International Thomson (1996).
[15] MEYER (B.). – Eiffel : The Language. 2e éd.
Prentice Hall (1992).
O
[2] ARON (P.) et PRADENC (H.). – La Java Card
débarque. Le Monde Informatique 739 (24
octobre 1997), 4.
[9] GOLDBERG (A.) et ROBSON (D.). – Smalltalk-
80 : The Language and its implementation.
Addison-Wesley (1983).
[16] MEYER (B.). – An Object-oriented environ-
ment : principles and application. Prentice
Hall (1994).
I
[3] BARNES (J.). – Programming in Ada 95.
Addison-Wesley (1995).
[10] HAROLD (E.R.). – Java Network Program-
ming. O’Reilly (1997).
[17] MEYER (B.). – Reusable software : the base
object-oriented component libraries. Pren-
R
[4] BELLOT (P.). – Conception et programmation [11] HOLMES (J.). – Object oriented compiler tice Hall (1994).
par les objets, le langage Eiffel. Soumis pour construction. Prentice Hall International
parution chez Eyrolles, 250 p., Paris (1997). (1995). [18] MORREY (B.) et HAMMOND (E.). – Java, por-
table avec certaines limites. Le Monde Infor-
[5] BELLOT (P.) et ROBINET (B.). – Conception de
logiciels et portabilité (H 3 288). Techniques
de l’Ingénieur, traité Informatique (1998).
[12] JAMES GOSLING (B.J.) et STEELE (G.). – The
JavaTM language specification. Addison-
Wesley, The Java Series (1996). [19]
matique 736 (3 octobre 1997), 26-27.
NOLIN (L.). – Formalisation des notions de
P
[6]

[7]
STROUSTRUP (B.). – The Design and Evolu-
tion of C++. Addison-Wesley (1994).
BURGER (C.). – Deuxième symposium inter-
[13]

[14]
JEANSEN (K.) et WIRTH (N.). – Pascal. Sprin-
ger-Verlag (1974).
LINDHOLM (T.) et YELLIN (F.). – The JavaTM [20]
machine et de programme. Gauthier-Villars
(1969).
SAINT-ÉLIE (L.). – Compatibilité Java : le dia-
L
national Java - 100 % Java, sinon rien ! Le
Monde Informatique 739 (24 octobre 1997), 4.
virtual machine. Addison-Wesley, The Java
Series (1996).
logue de sourd Sun-Microsoft. Le Monde
Informatique 739 (24 octobre 1997), 44-45. U
S
Outils de développement

D’après [1], le marché des outils de développement pour le langage Java En dehors de ces riches environnements de développement, il est possible
aura été dominé en 1997 principalement par quatre acteurs : Microsoft, de s’initier à Java sans bourse délier, avec le JDK, Java Development Kit de
Symantec, Sun et IBM. Ils représentent à eux seuls près de 80 % des revenus Sun Microsystems Inc., qui est téléchargeable à partir de
estimés de ce marché. En 1998, Borland devrait les rejoindre. Ils proposent les
http://java.sun.com/products/jdk.
environnements de développement graphiques suivants :
— Microsoft Visual J++, URL : Le JDK contient le minimum nécessaire à la programmation en Java :
http://www.microsoft.com/visualj ;
— les différents paquetages de Java ;
— Symantec Visual Café for Java, URL :
— le compilateur Java en ligne, javac ;
http://www.symantec.com/domain/cafe/deved ;
— Sun Java Workshop, URL : — la machine virtuelle et son interpréteur, java ;
http://www.sun.com/workshop/java ; — le visualisateur d’applet, permettant d’exécuter des applets sans utiliser
— IBM VisualAge for Java, URL : de navigateur Web, appletviewer ;
http://www.software.ibm.com/ad/vajava ; — le débogueur Java, jdb ;
— Borland JBuilder, URL : — le désassembleur de classes compilées, javap ;
http://www.borland.com/jbuilder. — le générateur de documentation qui suppose une certaine discipline
dans l’écriture des commentaires, javadoc ;
Une comparaison de ces environnements peut être consultée à l’adresse
Web : — des outils pour RMI ou la création de signatures d’applet ;
http://www.javaworld.com/javaworld/jw-11-jvtools.html. — bien d’autres outils : archiveurs, pour les nouvelles versions, etc.
Le choix des utilisateurs figure dans : On trouvera aussi bien d’autres paquetages permettant de réaliser des fonc-
http://www.developer.com/news/userschoice/111297_ide.html. tions importantes : JavaHelp pour la création de documentation en ligne,
JavaBlend pour l’écriture d’application accédant aux bases de données, Java-
Enfin, une liste très complète de tous les environnements de développe- Mail pour accéder au courrier électronique, Java Electronic Commerce Fra-
ment pour Java est tenue à jour dans : mework pour la programmation d’outils de commerce électronique, JavaIDL
http://www.javaworld.com/javaworld/tools/jw-tools-ide.html. pour interopérer avec CORBA, etc.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. − © Techniques de l’Ingénieur, traité Informatique Doc. H 3 088 − 1