Initiation à la Programmation Java

Initiation à la Programmation Java (4GI) Michel Cubero-Castan 8/10/2006

Copyright (c) 2003 Michel Cubero-Castan Tous droits réservés.

Table des matières 1 Java Computing... 1.1 Introduction... 1.2 Evolution du modèle informatique... 1.2.1 Le modèle centralisé... 1.2.2 Le modèle réseau local... 1.3 Les avantages de Java... 1.4 Le modèle d'exécution... 1.5 Environnement multi-plateforme (matérielle)... 1.6 Plateforme Java... 2 2 2 2 3 4 4 5 6 2 Système de développement JDK... 8 2.1 Classe, Instance, Variable, Méthode... 8 2.2 Hiérarchie, Héritage, Interface, Paquetage... 9 2.3 Exemple de programme Java... 11 2.4 Classpath... 12 2.5 Les outils de JDK... 14 2.5.1 javac... 15 2.5.2 java... 16 2.5.3 javadoc... 16 2.6 L'application ANT (Apache)... 17 2.6.1 Fichier XML de description... 17 2.6.2 Lancement de ANT... 18 3 Les bases de Java... 3.1 Les bases traditionnelles... 3.1.1 Lexicographie... 3.1.2 Commentaires... 3.1.3 Identificateurs... 3.1.4 Les variables... 3.1.5 Les types primitifs... 3.1.5.1 Les nombres entiers... 3.1.5.2 Les nombres flottants... 3.1.5.3 Les booléens... 3.1.5.4 Les caractères... 3.1.6 Les chaînes de caractères... 3.1.7 Les tableaux... 3.1.8 Les opérateurs... 3.1.8.1 Opérations arithmétiques... 3.1.8.2 Concaténation de chaînes de caractères... 3.1.8.3 Opérations de comparaisons... 20 20 20 20 20 21 21 22 22 22 22 23 23 24 24 25 25

3.1.8.4 Opérations logiques... 3.1.8.5 Opérations de manipulation binaire... 3.1.8.6 Affectation... 3.1.8.7 Conversion... 3.1.8.8 Précédence des opérateurs... 3.1.9 Les structures de contrôle... 3.1.9.1 Le bloc d'instructions... 3.1.9.2 Branchement conditionnel... 3.1.9.3 Choix multiple... 3.1.9.4 Boucles... 3.1.10 Les exceptions... 3.2 Les bases de l'orientation objet... 3.2.1 Les paquetages... 3.2.2 Les classes... 3.2.3 Les méthodes... 3.2.4 Les constructeurs... 3.2.5 Les interfaces... 3.2.6 Les variables... 3.3 Exemple de classe, l'heure... 3.4 Variations sur le polymorphisme... 3.4.1 Le problème initial... 3.4.2 Polymorphisme de méthode (surcharge)... 3.4.3 Méthode abstraite... 3.4.4 Interface... 3.4.5 Interface et méthode abstraite... 3.4.6 Classe membre statique... 3.4.7 Classe membre... 3.4.8 Classe locale... 3.4.9 Classe anonyme... 3.5 Allocation dynamique d'objets... 3.5.1 Clone... 3.5.2 Libération... 3.5.3 Options (non standards) de la commande java... 25 26 27 27 28 28 29 29 30 30 33 35 35 36 38 42 45 46 48 49 50 50 51 52 52 53 54 55 56 57 57 59 61 4 API standard... 4.1 Utilisation de l'api... 4.2 java.lang.*... 4.2.1 Classes liées au langage... 4.2.2 Classes liées à la machine virtuelle... 4.3 java.util.*... 4.3.1 java.util.stringtokenizer... 4.3.2 java.util.vector... 4.3.3 java.util.enumeration... 4.3.4 java.util.hashtable... 4.3.5 java.util.observer et java.util.observable... 62 62 63 63 65 66 66 67 68 69 70

4.4 java.io.*... 72 4.4.1 Entrées-sorties standard... 72 4.4.2 Entrées-sorties sur fichiers... 73 5 Réflexion... 5.1 java.lang.class... 5.2 Création d'instance... 5.3 Appel de méthode... 5.4 Traitement des variables... 76 76 78 79 80 6 Les Threads... 6.1 Utilisation des Threads... 6.1.1 Classe java.lang.thread... 6.1.2 Interface java.lang.runnable... 6.2 Cycle de vie des Threads... 6.3 Ordonnancement des Threads... 6.4 Synchronisation des Threads... 6.5 Groupe de Threads... 6.6 Les processus... 81 82 82 82 83 84 85 88 90

Polycopié du cours de Java Java est le dernier né des langages de programmation par objets, résultat de plusieurs années de recherche et de développement pour Sun. C'est le premier langage qui offre une solution complète, robuste et indépendante des plates-formes au problème de la programmation d'applications pour l'internet. Ce cours est une initiation à la programmation Java, en particulier la programmation répartie en Java. Si vous trouvez une erreur dans cette version du polycopié, vérifiez d'abord si l'erreur n'a pas déjà été corrigée dans la version en ligne. Si ce n'est pas le cas, merci d'en faire part par courrier électronique à l'adresse Michel.Cubero-Castan@insa-toulouse.fr. Page 1 sur 92

Chapitre 1 Java Computing 1.1 Introduction En Décembre 1990, le constructeur Sun Microsystems monte une petite équipe de programmeurs chargée de concevoir un environnement de programmation pour des appareils d'électronique grand public, en particulier les récents PDA (Assistants Numériques Personnels) tel le Newton d'apple, ou encore les futurs décodeurs pour la télévision intéractive. Dirigée par Bill Joy, cette équipe comprend notamment James Gosling, un ancien étudiant du département d'informatique de l'université Carnegie Mellon, spécialiste des logiciels en réseau, dont le rêve était de créer un langage simple et robuste, capable de piloter toutes sortes d'appareils du téléphone portatif au grille-pain. Dès sa création, l'équipe met au point le langage de programmation OAK. Le premier programme écrit en OAK s'exécute en Août 1991 grâce à un interprète écrit en C (le premier compilateur OAK était également écrit en C). Trois ans plus tard, suite aux déboires des pionners du PDA et au manque d'enthousiasme que suscitaient les décodeurs de télévision interactive, Sun oriente son équipe vers les aspects Internet alors en plein essor (Le programme Mosaic a été lancé en 1993). Le nouveau langage est alors baptisé Java et devient véritablement célèbre après l'annonce par Netscape le 23 Mai 1995 que son butineur Navigator, qui représentait alors 85% du trafic sur le Web, allait l'incorporer. Java est plus qu'un simple langage de programmation, c'est une véritable révolution dans la manière d'aborder l'informatique d'entreprise. Cette philosophie s'appelle le Java Computing. 1.2 Evolution du modèle informatique 1.2.1 Le modèle centralisé Au début de l'informatique, les systèmes informatiques étaient basés sur un modèle centralisé (Figure 1.1). Le système était composé d'une grosse machine (mainframe) sur laquelle étaient connectés plusieurs terminaux. Page 2 sur 92

Fig 1.1 : Modèle informatique centralisé Cette organisation présentait plusieurs avantages. Par exemple, l'utilisateur pouvait avoir accès à l'ensemble de ses fichiers et programmes depuis n'importe quel terminal. Ou encore, s'il était le seul utilisateur du système à un instant donné, il bénéficiait de l'ensemble des ressources de la machine, en particulier, l'unité centrale. Pour l'ingénieur système, le fait de gérer une seule machine était un point positif : un seul système d'exploitation à connaître, un seul matériel à connaître. Malheureusement, ces avantages pouvaient devenir facilement des inconvénients. Par exemple, à partir du moment où l'utilisateur n'est plus seul, il faut partager la puissance de la machine. Ce partage se réduit à zéro en cas de panne de la machine. Côté évolution, elle ne peut être que globale, dans le sens où augmenter la puissance de la machine implique un changement complet. 1.2.2 Le modèle réseau local Après le modèle centralisé, sont apparus les réseaux locaux. Plusieurs postes de travail étaient connectés sur un réseau local, comprenant également un ou plusieurs serveurs (Fig 1.2 ). Fig 1.2 : Modèle informatique réseau local Avec une telle organisation, il est possible d'avoir un poste de travail adapté à l'utilisateur. Dans la mesure où ce dernier ne nécessite qu'une machine de petite puissance, on arrive à des coûts réduits, du moins pour le matériel. Cependant, la multiplication des postes de travail dans une entreprise conduit à la multiplication des ressources logicielles : chaque machine doit avoir son système d'exploitation (pas forcément le même Page 3 sur 92

sur tous les postes de travail), ses outils de bureautique (courrier électronique, navigateur intranet, traitement de texte, tableur,...). Tous ces logiciels introduisent des coûts supplémentaires (maintenance pour les logiciels achetés, développement plus important pour les logiciels maison), sans compter les coûts indirects liés à l'administration de ces machines (coûts proportionnels à l'incompatibilités des postes de travail et des systèmes). Le coût annuel d'exploitation d'un simple poste de travail peut devenir très élevé. Le Gartner Group l'a évalué à 11.900$ par poste et par an (Gartner Group, Strategic Planning Research Note, SPA-14022, 26 avril 1996). De son côté, Sun estime le coût d'exploitation de postes de travail Java inférieur à 2.500$;. 1.3 Les avantages de Java L'approche Java (plate-forme de développement et environnement d'exécution) offre beaucoup d'avantages : Il permet de créer des applications offrant une meilleure sécurité au niveau de l'exécution. Cette sécurité est possible surtout par la vérification de tout le code avant son exécution. Elle vient aussi de l'absence, dans le langage, de la notion de pointeur. Il permet de créer des applications adaptables à des environnements changeants, simplement par le fait que le code peut être téléchargé avant l'exécution, à partir de n'importe quel point serveur d'un réseau. Cette notion d'adaptabilité doit être reliée à la notion de portabilité assurée par la machine virtuelle Java (dans la mesure où celle-ci existe pour chaque type de machine). Cette portabilité est clairement mise en avant dans le leitmotiv de Java : write once, run everywhere. Du point de vue du programmeur, Java permet de réduire le temps de développement d'une application grâce à la réutilisabilité du code développé. L'apprentissage de Java est facilité par la ressemblance avec les langages C et C++. Le succès de Java autant au niveau des programmeurs (en Octobre 1996, selon une estimation de Sun, ils étaient plus de 200~000 à utiliser ce langage) que des constructeurs (la machine virtuelle Java existe pour un grand nombre de systèmes, Apple, IBM, Microsoft, Novel, Silicon Graphics,..., quelque fois directement intégrée dans le système d'exploitation) laisse penser que, dans un proche avenir, la plateforme logicielle qui sera la plus diffusée ne sera plus Window mais la machine virtuelle Java. 1.4 Le modèle d'exécution La clé du modèle d'exécution Java repose sur un langage machine intermédiaire unique pour toutes les machines virtuelles Java. La mémorisation d'un programme en code machine intermédiaire s'effectue dans un fichier ayant.class pour extension. Le format des données dans ce fichier est unique. Ainsi, le même fichier peut être lu indifféremment par l'une ou l'autre des machines virtuelles Java, que ce soit dans un environnement Window, Macintosh ou Unix (Fig 1.3 ). Page 4 sur 92

Fig 1.3 : Modèle d'exécution Java Au niveau de la compilation, cela implique que les différents compilateurs disponibles produisent tous un fichier exécutable dans un format commun. De cette manière, il est possible de compiler un programme Java dans un environnement unix sur une machine Sun, puis de porter le fichier obtenu sur un Macintosh et l'exécuter par la machine virtuelle propre à Apple. C'est ce qui permet, entre autre, son utilisation sur internet. 1.5 Environnement multi-plateforme (matérielle) Pour s'exécuter, un programme Java dispose d'un environnement multi-plateforme. Il en existe pour plus de 34 systèmes d'exploitation différents, tournant sur plus de 10 processeurs différents. La figure 1.4 présente les diverses composantes de cette plateforme. Page 5 sur 92

Fig 1.4 : Environnement multiplateforme Java Tout d'abord, il convient de distinguer deux sortes de programmes Java : l'application Java et l'appliquette (Applet en anglais) Java. L'application est un programme comme ceux que nous avons l'habitude de créer. Pour s'exécuter, il a besoin d'une machine virtuelle Java. Une appliquette est un programme (en général de taille réduite) qui ne peut pas s'exécuter tout seul, mais à l'intérieur d'une autre application (par exemple le navigateur de Netscape). Appliquette et application s'exécutent grâce à une machine virtuelle (JVM : Java Virtual Machine). Cette machine dispose d'un chargeur (pour charger le code exécutable à partir du réseau internet), d'un vérifhcateur chargé de contrôler le code (pour la sécurité), et d'un interprète chargé d'exécuter le code. Le code peut faire appel à des fonctions disponibles dans une bibliothèque : l'api Java (Application Programming Interface) dont seule une petite partie est dépendante du système d'exploitation (classes PEER). L'exécution d'un programme Java n'est pas des plus rapides puisque interprété. La machine virtuelle peut toutefois s'accompagner d'un compilateur JIT (Just In Time), un compilateur à la volée. Ce type de compilateur transforrme le code machine Java en code machine pour l'unité centrale hôte, pendant l'exécution du programme. Cette approche permet de conserver la nature portable du programme écrit en Java, tout en bénéficiant des avantages de la compilation classique au niveau de la vitesse d'exécution. 1.6 Plateforme Java Page 6 sur 92

La plateforme Java désigne l'environnement qui permettra à un programme java de s'exécuter. Alors que la plupart des plateformes possèdent des composantes matérielles et logicielles, la plateforme Java est purement logicielle. Elle comprend principalement deux éléments: la machine virtuelle la bibliothèque Java En fait, il n'y a pas une mais trois plateformes Java: J2ME : Java 2 Micro Edition J2SE : Java 2 Standard Edition J2EE : Java 2 Enterprise Edition La plateforme Micro Edition est celle utilisée pour l'utilisation de Java sur des appareils du type carte à puce, téléphone, etc. La plateforme Standard Edition est la plateforme généralement utilisée pour le développement d'application Java. La plateforme Enterprise Edition est utilisée pour le développement d'applications modulaires de grande taille, grâce à un ensemble de services intégrés pour le courier électronique, l'accès aux bases de données, etc. Page 7 sur 92

Chapitre 2 Système de développement JDK 2.1 Classe, Instance, Variable, Méthode Java est avant tout un langage de programmation orientée objet. Mais, qu'est-ce qu'un objet? Pour mieux cerner les différents concepts de la programmation objet en Java, regardons l'exemple d'un gestionnaire d'emploi du temps. La figure 2.1 montre un exemple de page qui pourrait être fournie par un tel gestionnaire. Fig 2.1 : Page d'emploi du temps On constate qu'il existe, dans cette page, beaucoup d'éléments différents : Un cadre avec titre Un cadre par jour Un cours à 9h35... Page 8 sur 92

Mais, il y a également beaucoup d'éléments semblables! Par exemple, l'élément cours multimédia par Mr C. Chaplin du Jeudi 18/09/1997 n'est pas tellement différent de l'élément correspondant au cours ayant lieu le Vendredi 19/9/97 à 11h15, si ce n'est l'indication de la salle et la date! On appellera classe, un modèle pour plusieurs objets semblables, partageant des caractéristiques communes. Dans notre exemple, nous pouvons avoir la classe des TD, représentée graphiquement par le schéma: La classe TD nous décrit des éléments qui possèdent les caractéristiques suivantes : une créneau horaire, un numéro de séance, un nom d'enseignement, un nom d'enseignant, une salle, un groupe d'élèves (indiqué implicitement par la position dans la colonne du jour: groupe A pour la position à gauche, groupe B pour la position à droite). Une instance de la classe TD n'est autre qu'un objet issu de cette classe. La classe est une notion abstraite, tandis que l'objet est la concrétisation de la classe. Dans notre page de la figure 2.1, nous avons deux objets instances de la classe TD : un TD pour le groupe A, le mardi 16/09/1997 à 9h15, et un TD pour le groupe B, le mardi 16/09/97 à 9h30. On appelle variable, un élément (ou une information) associé à un objet ou bien à une famille d'objets. Par exemple, dans notre classe TD, chaque caractéristique (créneau horaire, numéro de séance, nom d'enseignement,...) est une variable. Enfin, nous appellerons méthode, la description d'une action ou d'un comportement qui permet de modifier une ou plusieurs valeurs associées aux variables d'un objet d'une classe donnée. La méthode est définie au niveau de la classe et pourra s'appliquer sur toutes les instances d'une classe. Dans notre exemple du gestionnaire d'emploi du temps, nous pourrions définir la méthode déplacer, qui nous permettra de changer la position d'un TD dans le planning. Cette méthode sera appliquée sur l'instance TD du groupe A du mardi 16/09/1997 à 9h15, pour éventuellement le déplacer au vendredi matin à 8H. 2.2 Hiérarchie, Héritage, Interface, Paquetage Page 9 sur 92

Poursuivons l'examen de la figure 2.1. Nous avons deux éléments n'appartenant pas à la même classe, mais possédant des caractéristiques communes, l'instance de la classe Note et l'instance de la classe Cours: Ces deux classes présentent, en effet, des points communs. Elles possèdent la même variable (créneau horaire) et la même forme de représentation (un grand rectangle). Elles peuvent posséder des méthodes communes, par exemple la méthode déplacer. Appelons créneau, la classe correspondant à l'ensemble de ces points communs. Nous pouvons maintenant redéfinir la classe Note en disant que c'est un créneau auquel nous avons rajouté de nouvelles variables et de nouvelles méthodes. Nous pouvons faire de même pour la classe Cours. Nous avons défini ainsi une hiérarchie entre les classes : Nous dirons que créneau est la super-classe de Note et Cours, et récriproquement, Note et Cours sont des sous-classe de Créneau. Une sous-classe hérite des variables et des méthodes de sa super-classe. Pour définir la classe Cours, il suffit d'indiquer qu'elle va hériter de la classe Créneau, et d'indiquer les nouvelles variables et méthodes. L'effort de programmation est ainsi diminué, tout ce qui a été fait n'est plus à faire. Un des points particulièrement intéressant de l'héritage réside dans la possibilité de voir un objet sous plusieurs visages. Par exemple, une instance de la classe Cours peut aussi être vue comme une instance de la classe Créneau (dans ce cas, on ne peut utiliser que les méthodes utilisables par la classe Créneau). Certains langages de programmation orientée objet permettent la définition d'une classe à partir de plusieurs classes n'ayant aucun lien entres elles. On parle alors d'héritage. Le langage Java ne le permet pas. Java n'offre que l'héritage simple. Une classe ne peut avoir qu'une seule super-classe. De même, cette super-classe ne peut avoir qu'une seule super-classe qui elle même ne peut avoir... Où arrêter le raisonnement? Sur une classe racine. Là aussi, Java simplifie les choses en n'ayant qu'une seule classe racine possible. Cette classe est la classe Objet. De ce fait, tout objet Java hérite, directement ou indirectement, de cette classe unique. Il n'y a pas de possibilité d'héritage multiple en Java. Ceci n'est pas en soi un problème. L'héritage multiple permet à un objet d'être vu comme un objet issu de l'une de ses super-classes. Avec l'héritage simple de Java, il est possible de voir un objet comme appartenant à une classe différente de la classe Page 10 sur 92

dont il est issu directement ou indirectement, grâce à la notion d'interface. Une interface décrit la possibilité d'un comportement particulier. La bibliothèque standard Java (API) contient un grand nombre de classes et interfaces (211 pour JDK 1.0.2, 477 pour JDK 1.1.5). Trouver un nom unique pour chacune de ces classes ou interfaces serait une tâche ardue s'il n'existait pas la notion de paquetage. Un paquetage est un regroupement de classes, d'interfaces et même de paquetages. Une classe particulière CL faisant partie du paquetage P2, lequel fera partie du paquetage P1 sera désignée par P1.P2.CL. La bibliothèque standard Java se trouve dans le paquetage java. Dans l'api 1.0.2, nous pouvons trouver les paquetages suivants: java.lang java.util java.io java.net java.awt Le paquetage java.util contient lui même les classes: java.util.enumeration java.util.hashtable java.util.date 2.3 Exemple de programme Java Le programme ci-dessous est un exemple de petit programme Java permettant de calculer le nombre de jours qui nous séparent du premier janvier de l'an 2000. package ch2; import java.util.calendar; /** * Programme calculant le nombre de jours depuis l'an 2000 * @author Michel Cubero-Castan * @version 1.2 * @since JDK1.1 */ public class An2000 { private static Calendar calendrier = Calendar.getInstance(); /** * Méthode principale du programme calculant le nombre de jours * qui nous séparent du premier janvier de l'an 2000. * * @param args les paramètres du programme (non utilisés) */ public static void main(string[] args) { long aujourdhui = calendrier.gettime().gettime(); calendrier.clear(); calendrier.set(2000,0,1,0,0,0); // 1er janvier 2000, 0h00 long an2000 = calendrier.gettime().gettime(); long nbrsecdepuis2000 = (aujourdhui - an2000) / 1000; Page 11 sur 92

long nbrjoursdepuis2000 = nbrsecdepuis2000 / (24*60*60); System.out.println("= Il est passé " + nbrjoursdepuis2000 + " jours, depuis l'an 2000."); Ce programme se présente sous la forme d'une classe ayant pour nom An2000 et faisant partie du paquetage ch2 (Attention aux lettres majuscules et minuscules, Java est sensible aux lettres capitales). Toute définition de classe publique (nous verrons plus tard ce que signifie ce terme) doit être mémorisée dans un fichier source ayant pour nom, le nom de la classe, et.java pour extension. De plus, si cette classe fait partie d'un paquetage, le fichier source doit se trouver (pour pouvoir être retrouvé par le compilateur) dans un répertoire ayant le même nom que le paquetage. Ainsi, le fichier source du programme An2000 aura pour nom An2000.java et sera placé dans le répertoire ch2 : Lorsque nous compilerons ce fichier, nous obtiendrons un fichier par classe compilé. Le nom de ce fichier sera le nom de la classe, avec.class pour extension. Si la classe appartient à un paquetage, le fichier compilé devra résider dans un répertoire ayant comme nom, le nom du paquetage. Pour notre programme An2000, nous aurons donc : 2.4 Classpath La seule contrainte imposée par Java sur la position d'un fichier (.java ou.class) est d'être dans un répertoire du même nom que le paquetage de la classe. Il n'y a pas de contrainte sur la position du Page 12 sur 92

paquetage racine. Comment la machine virtuelle va-t-elle trouver son chemin d'accès? Elle utilise la variable d'environnement CLASSPATH pour retrouver ce chemin. Cette variable donne les différents répertoires dans lesquels la machine virtuelle Java va rechercher les différentes classes qui ne font pas partie du paquetage standard java (l'ensemble des classes du paquetage standard java se trouvent dans une archive java connue de la machine virtuelle java; il n'est pas besoin d'en indiquer l'emplacement). Ces répertoires sont séparés par le caractère :. Si la classe recherchée appartient à un paquetage, par exemple la classe P1.P2.P3.CL, un des répertoires indiqués par la variable CLASSPATH doit contenir le répertoire P1 et non pas la classe CL. Par défaut, si cette variable n'est pas positionnée, la machine virtuelle Java utilise le répertoire courant. Bien entendu, les répertoires contenant les fichiers ".class" peuvent être différents des répertoires contenant les fichiers ".java". Par exemple, nous pouvons répartir ces deux types de fichiers dans deux répertoires, Sources pour les fichiers ".java" et Classes pour les fichiers ".class", en utilisant un paquetage différent par chapitre. Nous aurons ainsi, des répertoires organisés comme suit (le répertoire /home/gringo pouvant être le répertoire de login, contenant les répertoires Sources et Classes) : Il existe deux manières de spécifier le chemin de recherche des classes: en utilisant la variable d'environnement CLASSPATH, ou par l'intermédiaire du paramètre -classpath d'une commande d'exécution d'un des outils du système de développement. Par exemple, pour compiler, puis exécuter le programme An2000, si les répertoires Sources et Classes se trouvent dans le répertoire de login de Page 13 sur 92

l'utilisateur (désigné ici par /home/gringo), nous utiliserons l'une des deux séquences de commandes (type unix) suivantes : variable d'environexport CLASSPATH=/home/gringo/Classes:/home/gringo/Sources nement javac -d /home/gringo/classes An2000.java java ch2.an2000 paramètre de commande cd /home/gringo/sources/ch2 javac -classpath /home/gringo/classes:/home/gringo/sources/ -d /home/gringo/classes An2000.java java -classpath /home/gringo/classes ch2.an2000 2.5 Les outils de JDK JDK (Java Development Kit) est le système de développement de référence fourni par Sun. Il en existe plusieurs versions, dénotées par JDKx.y.z où x est un numéro de version correspondant à une évolution majeure du langage. y est un numéro de version correspondant à une évolution au niveau de l'api. z est un numéro de version correspondant à une correction d'erreur. La première version publique accessible fut la version JDK1.0.0. Il y a une compatibilité ascendante entre les différentes versions. L'avant dernière version (JDK1.1.8) est maintenant acceptée par la plupart des principaux navigateurs. C'est celle utilisée pour les différents exercices. Dans la suite de ce polycopié, nous indiquerons les éléments de JDK1.1, nouveaux par rapport à la première version. La version actuelle est la version JDK1.2.2. Le premier système de développement JDK1.0 comprenait les outils suivants: Le compilateur Java. Il produit du code intermédiaire (le bytecode). javac java L'interprète de bytecode. jdb Le débogueur Java. javah Un générateur de fichier d'en-tête C (".h") et de programme de conversion des arguments, utilisé appeler des procédures C à partir de programme Java. javap Un programme desassembleur permettant de visualiser les fichiers de bytecode Java. javadoc Le générateur de documentation en HTML à partir des commentaires contenus dans le programme Java. appletviewer Un visualiseur d'applet (principalement utilisé pour les tests). Le système de développement JDK1.1 comprend, en plus des outils précédents, les outils suivants: L'interprète de bytecode destiné à être utilisé en mode production (lorsque le jre processus de développement est terminé). jar Un programme permettant de combiner plusieurs fichiers de bytecode Java, ainsi que d'autres types de fichiers (images, son,...) en un seul fichier archive. javakey Un outil pour les signatures digitales. Page 14 sur 92

native2ascii Un outil pour convertir un fichier utilisant des caractères spéciaux en un fichier ASCII, en utilisant la notation unicode \udddd. rmic Un outil pour générer les interfaces de conversion pour les classes contenant des objets distants. rmiregistry L'outil d'enregistrement des objets distants. serialver Outil permettant d'obtenir la version de sérialisation d'une classe. updateawt Outil de conversion pour le passage de l'awt 1.0 à l'awt 1.1. Le plus récent système de développement, JDK1.2, contient un beaucoup plus grand nombre de nouvelles classes. On trouve ainsi également de nouveaux outils, comme des outils pour l'internationalisation des programmes, des outils pour la sécurité des applications, ainsi que des outils liés à CORBA. Examinons plus attentivement, les outils les plus importants. 2.5.1 javac Le compilateur javac s'appelle avec la commande de même nom. Il est possible de compiler une ou plusieurs classes. Plusieurs paramètres optionnels peuvent être utilisés avec cette commande. Nous ne décrirons ici que les plus utiles pour un apprentissage java. $ javac [option] nomfichier1.java nomfichier2.java... La commande javac compile chaque nom de fichier passé comme paramètre à la commande. Pour chaque classe contenue dans les fichiers sources, le compilateur produit un fichier de bytecode java ayant pour nom le nom de la classe compilée et pour extension ".class". Ces fichiers de bytecode sont placés dans le même répertoire que le fichier source sauf si l'option -d est utilisée. Dans ce cas, les fichiers de bytecode Java sont placés dans le répertoire indiqué par l'option. Si la classe compilée fait partie d'un paquetage, il est préférable d'utiliser cette option et d'indiquer dans l'option, le répertoire racine de la hiérarchie de classe. Lors de la compilation d'une classe faisant référence à une deuxième classe, le compilateur recherche (grâce à la variable d'environnement CLASSPATH ou à l'option -classpath) le fichier source et le fichier bytecode correspondant à cette deuxième classe. Une compilation de la seconde classe est effectuée si, soit le fichier bytecode de la seconde classe n'existe pas, soit la date de modification du fichier source est postérieure à la date de modification du fichier bytecode. Cette vérification n'est pas reconduite pour les classes qui seraient référencées par cette deuxième classe, sauf si l'option -depend est utilisée. Dans ce cas, le processus de compilation est effectué pour toute classe référencée directement ou indirectement par la classe compilée. Pour faciliter l'utilisation de l'outils de mise au point jdb, il faut utiliser l'option -g qui permet au compilateur de générer dans le bytecode, les informations pouvant servir à la mise au point (comme les noms de variables, la numérotation des lignes sources,...). Enfin, il existe, depuis la version JDK1.1, un certain nombre de méthodes marquées deprecated c'est à dire des méthodes dont l'usage n'est pas recommandé. Ce sont des méthodes de la première version qui ont été conservées dans la version 1.1 pour assurer une compatibilité ascendante, mais Page 15 sur 92

qui peuvent être remplacées par de nouvelles méthodes de cette dernière version. En principe, ces méthodes dépréciées pourront être retirées dans les versions futures. Le compilateur JDK1.1 indique à la fin de la compilation si la classe compilée utilise de telles méthodes dépréciées. Il est possible d'obtenir un message d'avertissement pour chaque méthode utilisée, avec l'option de compilation -deprecation. Exemple: Pour compiler notre programme An2000, nous devons exécuter la commande unix suivante (dans le répertoire ch2 contenant le fichier source): $ javac -g -d../../classes/ An2000.java 2.5.2 java La commande java permet d'exécuter la méthode main de la classe dont le nom complet (nom du paquetage inclu) est passé en argument. La méthode main doit avoir la signature suivante: public static void main(string argv[]){... La classe à exécuter doit avoir été compilé, puisque la commande java interprète le bytecode obtenu à l'issue de la compilation. De plus, le fichier contenant le bytecode doit être accessible via la variable d'environnement CLASSPATH. Comme la commande javac, la commande java peut contenir des options. La première option -classpath donne le chemin d'accès aux différentes classes. Une deuxième option -cs ou -checksource permet de vérifier si les dates de dernière modification des fichiers de bytecode des classes utilisées sont bien postérieure aux dates des fichiers sources correspondants. Dans la négative, une compilation est automatiquement effectuée avant le chargement de la classe. Une troisième option -debug permet de relier l'exécution du programme au débogueur, pour une mise au point du programme. D'autres options permettent de modifier certains paramètres de la machine virtuelle Java, ou d'obtenir des statistiques lors de l'exécution. Il est possible de transmettre des paramètres à un programme Java, via la ligne de commande: $ java [option] nomclasse paramètre1 paramètre2... Ces paramètres sont accessibles dans la méthode main, via le tableau de chaînes de caractères passé en paramètre. Il est également possible de transmettre un certain nombre de propriétés par la commande java, en utilisant l'option -D suivie du nom de propriété et de sa valeur (-Dnom=valeur ). Voici la commande unix et le résultat obtenu pour l'exécution de notre programme An2000 : $ java -classpath../../classes ch2.an2000 = Il reste 606 jours, avant l'an 2000. $ 2.5.3 javadoc Page 16 sur 92