Eléments sur JAVA

El´ements sur JAVA
Philippe Laroque
<[email protected]>
$Id : java.lyx 1602 2008-11-26 10 :04 :49Z phil $
R´esum´e
Ce petit document ne se substitue pas `a l’un des - nombreux - ouvrages disponibles sur JAVA.
Il pr´etend simplement servir d’aide-m´emoire `a l’utilisateur pour retrouver rapidement le contexte
d’utilisation d’une notion importante du langage.
1

1 INTRODUCTION
1 Introduction
JAVA a vu le jour en 1995, comme r´esultat d’un projet interne SUN de cr´eation d’un langage de haut
niveau. Le projet stipulait que le langage `a cr´eer devrait ˆetre portable, facile `a apprendre et suffisamment
ouvert pour permettre son extension ais´ee.
L’environnement JAVA disponible actuellement est la troisi`eme version de ce langage. Sa richesse,
en termes de domaines fonctionnels couverts, est telle qu’il est exclus de vouloir la couvrir en totalit´e
dans un cours de quelques heures. Nous nous bornerons ici `a faire ressortir les propri´et´es principales du
langage :
– sa portabilit´e, avec le mod`ele de machine virtuelle et une br`eve description des outils qui l’entourent
au sein du JDK (Java Development Kit) ;
– son orientation “objet”, axe que nous d´evelopperons plus particuli`erement puisqu’il est le socle sur
lequel viennent s’appuyer tous les modules du langage ;
– sa facilit´e d’apprentissage, du moins si on connaˆıt d´ej`a les langages C et/ou C++
1.1 Un premier exemple de programme JAVA
Ce programme affiche simplement une chaˆıne de caract`eres sur l’´ecran :
/* FirstExample.java
* un programme simple pour afficher une chaine de caracteres
*/
public class FirstExample {
public static void main(String args[]) {
System.out.println("premier programme JAVA") ;
System.exit(0) ;
}
}
Quelques remarques g´en´erales, avant d’entrer dans les d´etails dans les sections qui suivent :
– la ressemblance avec le langage C est importante, on verra qu’en fait JAVA est (presque) un sur-
ensemble de C en ce qui concerne la syntaxe de base ;
– tout code doit appartenir `a une classe (principe d’encapsulation, voir section 2.1.2 p. 6) ;
– toute classe peut d´efinir ce qu’elle publie et ce qu’elle garde cach´e (mot r´eserv´e public de l’exem-
ple) ;
– toute instruction (sauf les affectations) est un envoi de message (ici, `a l’objet pr´ed´efini System).
1.2 Quelques r´ef´erences
– Un tutorial de SUN, complet et assez bien fait :
http://java.sun.com/docs/books/tutorial
– Des sites sur les langages objet (et plus sp´ecialement JAVA) :
http://www.sigs.com
http://www.javaworld.com
– Un livre en ligne :
http://www.mindviewinc.com/
– Un “How-To” tr`es bien fait :
http://www.rgagnon.com/howto.html
– Des exemples de code (en fran¸cais) :
http://cui.unige.ch/java/
– Le site “bible” de l’objet en g´en´eral :
http://www.cetus-links.org
1.3 L’environnement de travail
L’objectif principal du langage est la portabilit´e. Un programme JAVA doit donc ˆetre ind´ependant
de la plate-forme mat´erielle et logicielle sur laquelle il s’ex´ecute. Pour atteindre ce but, les concepteurs
du langage ont r´ealis´es deux outils qui constituent la base des environnements de d´eveloppement JAVA :
– Une machine virtuelle, couche logicielle interm´ediaire entre le syst`eme d’exploitation et les appli-
cations ´ecrites en JAVA.
2

1.3 L’environnement de travail 1 INTRODUCTION
– Un compilateur (ou “semi-compilateur”), g´en´erant du code `a destination de la machine virtuelle.
1.3.1 La machine virtuelle JAVA
Cette couche isole les programmes JAVA des contraintes de l’environnement local, assurant ainsi leur
portabilit´e. Pour qu’un syst`eme puisse faire tourner des programmes JAVA (quels qu’ils soient), il faut et
il suffit que cette machine virtuelle (que dans la suite nous nommerons JVM, pour Java Virtual Machine)
ait ´et´e port´ee sur le syst`eme en question.
A l’heure actuelle, la JVM est port´ee sur la totalit´e des plate-formes “classiques” de d´eveloppement,
du mac au gros serveur UNIX en passant par les diverses d´eclinaisons de windows, linux etc.
La JVM est activ´ee
– soit explicitement, `a l’aide de la commande java suivie du programme qu’on souhaite ex´ecuter (le
nom d’une classe contenant une m´ethode main),
– soit implicitement dans un environnement plus riche qui la contient (par exemple, d´eclenchement
automatique d’une applet dans un navigateur web).
1.3.2 Le compilateur
Il s’agit en fait d’un semi-compilateur, dans la mesure o`u il ne g´en`ere pas du langage machine (qui
serait d´ependant de la plate-forme, donc non portable), mais un code interm´ediaire portable appel´e
bytecode.
Le compilateur est activ´e explicitement, en utilisant la commande javac suivie du ou des fichiers
sources `a compiler.
1.3.3 Le “documenteur”
Les concepteurs de JAVA ont eu l’initiative de proposer un m´ecanisme permettant d’extraire, dans le
code source lui-mˆeme, certains des commentaires qui s’y trouvent, puis de les traiter afin d’en produire
une documentation au format HTML, avec liens hypertextuels.
Tout constituant d’un programme (paquetage, classe, m´ethode, variable) peut ˆetre document´e. Pour
les d´etails, nous renvoyons le lecteur `a
http ://java.sun.com/j2se/javadoc/index.html
mais nous d´ecrivons tout de mˆeme ici les grands principes d’utilisation de cet outil, appel´e javadoc.
Les commentaires destin´es `a Javadoc commencent par “/**” et se terminent par “*/”. Tout ce qui
est situ´e `a l’int´erieur sera interpr´et´e comme du HTML, `a l’exception de quelques mots r´eserv´es dont nous
donnons plus loin un sous-ensemble fr´equemment utilis´e.
Tout mot r´eserv´e doit apparaˆıtre en d´ebut de ligne, exemple :
/**
* This is a <em>doc</em> comment.
* @see java.lang.Object
*/
Les commentaires relatifs `a une classe (resp. une m´ethode, une variable etc.) doivent apparaˆıtre juste
au-dessus de la d´efinition de la classe (resp. m´ethode, variable, etc.)
Quelques mots r´eserv´es utiles sont r´eunis dans le tableau ci-dessous. Tous commencent par “@”. Pour
chacun d’eux, on a indiqu´e la version du JDK `a partir de laquelle ils sont d´efinis.
mot-cl´e version signification
@author 1.0 l’auteur du fichier
@deprecated 1.0 code appel´e `a disparaˆıtre
@exception 1.0 code lan¸cant une exception
@param 1.0 param`etre de m´ethode
@return 1.0 valeur de retour
@see 1.0 lien vers un autre code
@since 1.1 anciennet´e du code
@version 1.0 version du code/document
3

1.4 Syntaxe de base 1 INTRODUCTION
Si les sources sont organis´ees de mani`ere arborescente pour respecter la hi´erarchie des paquetages, il
est possible de g´en´erer en une fois la totalit´e de la documentation de cette hi´erarchie, avec la commande
suivante (on suppose qu’on est plac´e `a la racine de cette hi´erarchie et que la documentation doit ˆetre
plac´ee dans $HOME/doc) :
javadoc -version -author -encoding UTF-8 \
-d $HOME/doc -sourcepath . pkg1 pkg2 ... pkgn
Les extraits de code Java qui suivent dans ce petit support fournissent des exemples d’utilisation des
“tags” list´es dans la tableau ci-dessus.
1.3.4 Autres outils
–appletviewer : outil de test permettant de lancer des applets sans navigateur web ;
–jar : outil permettant de placer dans un mˆeme fichier “archive” des fichiers concourant au fonc-
tionnement d’une application, ce qui facilite leur distribution (et leur ex´ecution distante) ;
–jdb : debugger assez basique, tr`es nettement am´elior´e par les divers IDE du march´e ;
–javah : g´en´erateur de fichiers en-tˆete C pour l’int´egration de m´ethodes natives ;
–javap : d´esassembleur de programmes JAVA
– ...
1.4 Syntaxe de base
Nous ne ferons ici qu’un tr`es bref passage sur la syntaxe de base de Java, dans la mesure o`u elle est
identique `a celle de C ou de C++ (en particulier, le langage est case-sensitive).
Dans la section 3 p. 10, on reprend en d´etail les ´el´ements de syntaxe propres `a JAVA.
1.4.1 Commentaires
Il y a trois types de commentaires :
– Les commentaires introduits par // se terminent implicitement en fin de ligne
– Les commentaires introduits par /* se terminent par */. Ils peuvent donc s’´etendre sur plusieurs
lignes.
– Les commentaires introduits par /** sont identiques aux pr´ec´edents, mais ils sont en outre r´ecup´er´es
par javadoc (voir 1.3.3 p. 3).
1.4.2 Types pr´ed´efinis
Les seuls types pr´ed´efinis en JAVA sont des types simples. Tous les autres types sont des classes, sur
lesquelles on revient plus loin. Les types simples de JAVA sont les mˆemes que ceux de C, `a l’exception
du type boolean qui n’existe pas en C. Le tableau suivant r´esume tout ceci :
Type contenu d´efaut1taille min/max
boolean true/false false 1 bit
byte sign´e 0 1 octet −128/127
char unicode \u0000 2 octets \u0000/\uFFFF
short sign´e 0 2 octets −32768/32767
int sign´e 0 4 octets ≈2∗109
long sign´e 0 8 octets ≈9∗1018
float IEEE754 0.0 4 octets ≈3∗1038
double IEEE754 0.0 8 octets ≈4∗10308
1.4.3 D´eclarations
Le typage de JAVA est statique : une variable doit ˆetre d´eclar´ee avant de pouvoir ˆetre acc´ed´ee. Cette
d´eclaration se fait en mentionnant son type et son nom (et en lui donnat ´eventuellement une valeur
initiale).
ex :
4

1.4 Syntaxe de base 1 INTRODUCTION
int i ;
double d = 3.1415926535 ;
char c = ’A’, d=’\u0108’ ;
Il y a une exception `a cette r`egle : `a l’int´erieur d’une classe (voir 2.1.3 p. 7), une variable d’instance peut
ˆetre utilis´ee dans une m´ethode d´eclar´ee avant la d´eclaration de la variable elle-mˆeme.
1.4.4 Les tableaux
Leur taille ne peut ˆetre fix´ee que dynamiquement. Pour d´eclarer un tableau dont les ´el´ements sont
de type T, on ajoute une paire de crochets apr`es le nom de la variable. La cr´eation effective du tableau
se fait par allocation dynamique de m´emoire, grˆace `a l’op´erateur new :
int monTableau[] = new int[100] ; // cr´ee un tableau de 100 entiers
monTableau[0]=3 ; // les indices commencent `a 0
On peut aussi cr´eer un tableau en donnant son contenu en extension ; la taille du tableau (attribut
length) est alors d´etermin´ee par le nombre d’´el´ements mentionn´es :
int[] anArray = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
1.4.5 Les op´erateurs
Tous ceux du C, `a part les op´erateurs sur les pointeurs. En effet, bien que JAVA ne manipule pra-
tiquement que des pointeurs, ces derniers ne sont pas accessibles au programmeur. En particulier, il n’y
a pas de moyen de r´ecup´erer l’adresse d’un objet.
Il y a trois grandes cat´egories d’op´erateurs, celles de C :
– les op´erateurs arithm´etiques (+, -, *, /, %, +=, -=, ++, --, etc.)
– les op´erateurs logiques ( !, &&, ||)
– les op´erateurs de bas niveau (&,|, ^, ~)
Un op´erateur sp´ecial, instanceof, permet de tester l’appartenance d’un objet `a une classe (ou `a une de
ses sous-classes). L’objet constant null n’appartient `a aucune classe, par construction.
1.4.6 Les structures de contrˆole
Identiques `a celles de C (if, while, for, switch). Un exemple :
for (int i = 0 ; i < n-1 ; i++) {
for (int j = i+1 ; j < n ; j++ {
if (tab[i] > tab[j]) {
int tmp = tab[j] ;
tab[j] = tab[i] ;
tab[i] = tmp ;
}
}
}
1.4.7 Les m´ethodes
L`a encore, syntaxe presque identique aux fonctions C : on fournit le type de retour, le nom, la liste
des param`etres et le corps de la fonction. Exemple :
void push(Object o) {
Node n = new Node(o,top) ;
top = n ;
}
`
A signaler : contrairement `a ce qui se fait en C, on peut donner le mˆeme nom `a deux versions diff´erentes
de la mˆeme m´ethode, pourvu que ces deux versions diff`erent soit par le nombre de param`etres, soit par
le type d’un des param`etres. On parle dans ce cas de surcharge.
5