Ecole d'ingénieurs de Genève Département de l'instruction Publique. Manuel Java

Transcription

1 Ecole d'ingénieurs de Genève Département de l'instruction Publique Manuel Java Eric Lefrançois - 5 novembre 2000

2 - 2 -

3 - 3 - T a b l e d e s m a t i è r e s 1. PREAMBULE 9 2. STRUCTURE D UN PROGRAMME : LES PAQUETAGES Elaboration et utilisation d un paquetage Elaboration Utilisation Les hiérarchies de paquetages Relations avec le système de gestion de fichiers Structure d une application Java Librairies de packages CLASSES ET OBJETS Généralités Comment déclarer une classe Variables d'instance Variables de classe Les méthodes Aperçu général Distinguer les procédures des fonctions Invoquer une méthode : l'envoi de message La portée des méthodes : «public», «private» et «protected» Les méthodes de classe et les méthodes d'instance (mot-clé «static») Les méthodes abstraites (mot-clé «abstract») Variables et paramètres Les constructeurs Le destructeur La surcharge des méthodes La redéfinition des méthodes La fonction «main» La récursivité Exceptions levées par une méthode Création d'un objet Copie d objets 52

4 Les mot-clés «this» et «super» HERITAGE ET POLYMORPHISME Java et le mécanisme d héritage Bien utiliser l'héritage L'héritage, un outil de spécialisation La relation «est-un» Le sous-typage La règle de substitution La redéfinition des méthodes Edition de liens dynamique Le type déclaré et le type courant d'un objet Règles à respecter lors de la redéfinition d une méthode Est-il possible de changer le mode de protection? Interdire la redéfinition, bloquer l héritage Les exceptions et la redéfinition Le polymorphisme Généralités Comparons Java, Smalltalk et C De l'intérêt du polymorphisme Méthodes abstraites Masquage d'un attribut (d une variable d instance) Un bilan sur les modes de protection Le mode «privé» Le mode «public» Le mode «protégé» Héritage et redéfinition du mode de protection Enchaînement des constructeurs Les classes abstraites Le mot-clé «super» Héritage d'une variable de classe Héritage d'une méthode de classe INTERFACES Implémenter une interface A quoi ça sert? 97

5 Quelques exemple tirés de la librairie Java LES TYPES DE JAVA Généralités Les types primitifs Les tableaux en Java Les chaînes de caractères Conversions de types Conversions entre types primitifs Conversions entre objets Conversions de types primitifs en objets Conversions entre numériques et chaînes de caractères LES EXPRESSIONS Les valeurs littérales Les opérateurs Evaluation d'une expression Liste des opérateurs avec leur priorité L'opérateur «new»: création d un objet L opérateur «.» : envoi de message, accès aux variables d un objet Opérateur «[]» Opérateurs arithmétiques : * / + - % Concaténation de chaînes : opérateur «+» Les opérateurs logiques : ==!!= & && Opérateur d'affectation : «=» Opérateurs d'affectation composé :«+=» «-=» «*=» Opérateurs «++» et «--» Le if arithmétique : «?:» Opérateurs de bits : ~ << >> >>> & ^ L'opérateur «instanceof» INSTRUCTIONS DE JAVA Les étiquettes d'instructions (labels) Instructions «expression» Instruction composite 140

6 Instructions conditionnelles (les «if») Instruction «if» Instruction «if» avec clause «else» La forme «else if» L'opérateur conditionnel «?:» Instruction «switch» Instructions itératives Instruction «while» Instruction «do» Instruction «for» Instructions de saut Instruction «break» Instruction «continue» Instruction «return» L'instruction «throw» L'instruction de synchronisation «synchronized» Instructions pour le traitement des exceptions LE TRAITEMENT DES EX CEPTIONS Le traitement des erreurs Lever une exception La propagation d une exception La récupération d une exception («try..catch») Hiérarchie des classes d exception Exceptions de type «RunTimeException» Exercice PROGRAMMATION CONCURRENTE EN JAVA Généralités Diagramme d états et de transitions Réaliser des objets actifs en Java Scheduling : politique d allocation du processeur Exclusion mutuelle : verrouillage d un objet 181

7 Rendez-vous entre threads Le mécanisme offert par Java Dans le détail Un modèle standard pour utiliser «wait()» Exemple: une file d'attente Les threads démons Les groupes de threads Annexes Méthodes de la classe «Thread» Méthodes de la classe «Object» Les threads de la machine virtuelle Les méthodes «stop()» et «suspend()» sont «deprecated» dans java Interruption des threads LES APPLETS Intérêt des applets Lancement d une applet, différence avec une application Le cycle de vie d une applet Dessiner dans une applet, ajout de composants «GUI» Les applets sont de riches héritières Dessiner dans une applet Un exemple : un chronomètre dans une applet Ajouter un composant «GUI» Les threads et les applets La sécurité et le droit des applets Ce qui est interdit aux applets Ce qui est permis aux applets Comment manipuler les ressources WEB dans une applet? La balise <APPLET> et les paramètres Points divers ENTREES-SORTIES EN JAVA Notion de flux Les flux à disposition dans la librairie Java Analyse des superclasses abstraites «Reader», «Writer», «InputStream» et «OutputStream» Utilisation des flux primaires Utilisation des flux de traitement 245

8 Un exemple: lecture et écriture dans un fichier d entiers Les flux standard «in» et «out» La sérialisation des objets Hiérarchie des types de fenêtres La classe «Component» La classe «Window» La classe «Dialog» La classe «Frame» Le gestionnaire de présentation «BorderLayout» Gestion des événements Première méthode : les «écouteurs» s abonnent aux événements Deuxième méthode : en utilisant les masques d événements QUELQUES ANNEXES La classe «StringTokenizer» Pour imprimer en Java Imprimer depuis une application autonome Imprimer depuis une applet Imprimer de façon un peu moins portable Applets : imprimer via des fichiers HTML 273

9 Préambule Java possède de nombreuses caractéristiques qui en font un des langages de choix pour l enseignement de l algorithmique et de la programmation. En effet, Java a été conçu pour mettre en œuvre des applications susceptibles de s exécuter sur n importe qu elle plate-forme, ce qui est très avantageux dans le cas d environnements scolaires hétérogènes. Java est un langage fortement typé, donc très sûr. Il offre en même temps une souplesse relative grâce aux opérations de coercition de type («casting»). En plus du typage fort, Java met à disposition plusieurs niveaux de protection des données (les modes «public», «protected», «private»,..), ainsi qu un mécanisme de traitement des exceptions très sophistiqué. Le programmeur est libéré de tous les aspects relatifs à la gestion de la mémoire : pendant l exécution d un programme, Java exécute en permanence un «garbage collecteur» qui nettoie automatiquement la mémoire des objets qui ne sont plus utilisés. Enfin, Java propose des outils et des mécanismes qui permettent au programmeur de faire de la programmation concurrente «multi-threaded», de réaliser des applications Internet, de mettre en œuvre des interfaces utilisateurs sophistiqués.

10 Voici un petit exemple destiné aux programmeurs qui auraient déjà pratiqué la programmation orientée objet au travers d'autres langages comme Smalltalk, C++,.. Le fichier présenté ci-dessous porte le nom «MotoCyclette.java». Il s'agit d'un programme Java, à exécuter en tant «qu'application autonome», qui s articule autour de la description d une seule classe, la classe «MotoCyclette» // public class MotoCyclette { // Variables d instance protected String marque; // Marque de la moto protected Color couleur ; // Couleur de la moto boolean enmarche; // «true» si le moteur est // enclanché // Constructeur public MotoCyclette (String unemarque, Color unecouleur) { marque = unemarque ; couleur = unecouleur ; enmarche = false ; // Deux méthodes public void démarrer () { if (enmarche){ System.out.println (" deja demarre "); else { enmarche = true; System.out.println (" demarrage OK "); public void afficherattributs () { System.out.println ("Voici mes attributs : " + marque + couleur); if (enmarche) System.out.println (" Mon moteur tourne "); else System.out.println (" Mon moteur est arrete "); // Quelques commentaires : La lecture de cette «classe» nous apprend qu une motocyclette est un objet caractérisé par 3 attributs : 1) une marque : "Yamaha", "Suzuki", 2) une couleur : «Color.blue», «Color.black», 3) un état, qui indique si oui ou non le moteur est en marche

11 Le «constructeur» utilise deux paramètres : la marque de la moto, ainsi que sa couleur. Ces deux valeurs devront être spécifiés au moment de la création d une nouvelle motocyclette. Les instructions du même constructeur nous signalent qu au moment de sa création, une motocyclette aura le moteur en état d arrêt. Un exemple de création d une nouvelle motocyclette : MotoCyclette unemoto ; // Déclaration d une variable qui servira à «référencer» // un objet de type «MotoCyclette» unemoto = new MotoCyclette ("Honda", Color.green) ; // Création dynamique de l objet, // référencé par la variable «unemoto» Une motocyclette est susceptible de répondre à deux «messages» : les messages «démarrer» et «afficherattributs». Envoi du message «démarrer»: unemoto.démarrer() ; L état de la moto est modifié: son attribut «enmarche» prend la valeur «true» Le texte " demarrage OK " est affichée à l écran Si la moto était déjà en marche, c est le texte " deja demarre " qui s afficherait Envoi du message «afficherattributs»: unemoto.afficherattributs () ; Le texte " Voici mes attributs : Honda Color.green " est affiché à l écran Un deuxième texte affiche l état du moteur. La compilation se fait à l'aide de la commande suivante : >javac MotoCyclette.java Il est nécessaire d'avoir une méthode «main()» pour toute application, sinon on aura l'erreur suivante: class MotoCyclette: void main (String argv []) is not defined. Aussi on va rajouter la méthode «main» comme troisième méthode dans la classe «MotoCyclette». La méthode «main» contient les instructions qui seront exécutées par le noyau Java au moment du lancement de l application.

12 public static void main (String argv []) { // Cette méthode crée un nouvel objet de la classe // MotoCyclette en stockant sa référence dans la variable m MotoCyclette m = new MotoCyclette (("Honda", Color.green)); // new = appel du constructeur System.out.println (" envoi du message afficherattributs "); m.afficherattributs (); System.out.println (" demarrage du moteur "); m.démarrer (); System.out.println (" envoi du message afficherattributs "); m.afficherattributs (); // Ré-affichage de l état System.out.println (" démarrage du moteur "); m.démarrer (); // Affichage du texte «deja demarre»

13 Structure d un programme : Les paquetages Chapitre emprunté en grande partie à M. Markus Jaton, EIVD Nous abordons dans ce chapitre un certain nombre d aspects de haut niveau, qui ont trait à la structuration d une application Java. Une application Java n est pas faite uniquement de classes qui s instancient les unes des autres : ce serait trop simple oui, mais aussi trop compliqué.. En effet, certaines applications Objet manipulent un nombre de classes tellement gigantesque que le programmeur en arrive très vite à s arracher les cheveux. Comment mettre de l ordre dans cette montagne de composants? La réponse de Java s inspire directement de la conception des systèmes de fichiers : les classes seront organisées en répertoires que l on appellera des «paquetages» (il contiendront chacun un paquet de classes). Un paquetage Java est un ensemble de classes et d interfaces (voir le chapitre correspondant) plus ou moins affiliées les unes aux autres, et souvent destinées à coopérer dans le cadre d une même application; ainsi, le paquetage «java.awt» rassemble tous les éléments de Java pouvant être affichés dans le cadre d une interface graphique.

14 Un avantage du groupage de classes en paquetage est que le risque de collision de noms s en trouve réduit. Supposons que le programmeur Bérurier définisse une classe nommée «Address» pour définir des adresses de clients, et que d autre part il importe une classe nommée «NoteBook» réalisée par un autre programmeur, qui a de son côté défini une classe «Address», différente de celle définie par Bérurier. Le pauvre Mr. Bérurier va se trouver forcé de changer le nom de sa classe en «MyAddress», ou renoncer d utiliser la classe «NoteBook». La définition de paquetage résoud le problème : on définira le paquetage «NoteBook» dans lequel est défini une classe «Address», et un paquetage «PackageDeBerurier», qui définira également une classe «Address»: les paquetages étant différents, il n y pas de collision. 2.1 Elaboration et utilisation d un paquetage Analysons le paquetage sous l angle syntaxique Elaboration On définit un paquetage par le truchement du mot reservé «package», suivi du nom de ce paquetage, et d un point-virgule. package MonPackage; class ClasseA {... int unemethodedea();... class ClasseB {... class ClasseC {... Un paquetage contient généralement plusieurs classes, qui sont définies généralement par plusieurs fichiers différents. Dans l exemple ci-dessus, les classes «ClasseA», «ClasseB» et «ClasseC» font partie du paquetage «MonPackage». Le mot-reservé «package», s il figure dans un fichier, doit être le premier mot de la première ligne significative (ni vide, ni commentaire) du fichier source. Si aucun paquetage n est mentionné, un paquetage par défaut sera défini par le compilateur, nommé «unnamed» Utilisation L utilisation d un paquetage est très simple : il suffit de préfixer un identificateur par son nom de paquetage; ainsi, utiliser «ClasseA» dans un programme utilisateur peut se faire très simplement de la manière suivante : class Test { void unemethode() { MonPackage.ClasseA mpa = new MonPackage.ClasseA(); int i = mpa.unemethodedea();

15 MonPackage.ClasseA mpa1 = new MonPackage.ClasseA(); int j = mpa1.unemethodedea(); MonPackage.ClasseA mpa2 = new MonPackage.ClasseA(); int k = mpa2.unemethodedea(); Un inconvénient évident est qu il faut retaper le nom du paquetage à chaque fois; Java permet d éviter cet excédent de texte au moyen du mot réservé «import», qui permet d ouvrir le contexte d un paquetage, et d éviter ainsi la répétition fastidieuse du nom des paquetage utilisés1. Ainsi, le petit exemple ci-dessus peut s écrire : import MonPackage.ClasseA; class Test { void unemethode() { ClasseA mpa = new ClasseA(); int i = mpa.unemethodedea(); ClasseA mpa1 = new ClasseA(); int j = mpa1.unemethodedea(); ClasseA mpa2 = new ClasseA(); int k = mpa2.unemethodedea(); Il est également possible d ouvrir le contexte du paquetage entier, et de définir ainsi toutes les classes du paquetage comme importées; la syntaxe est alors la suivante : import MonPackage.*; import java.awt.*; Il est en revanche nécessaire d adresser de manière explicite des classes ayant le même nom dans des paquetage différents. Il n est pas nécessaire d importer le paquetage dont fait partie la classe que l on utilise: cette importation est automatique. Il n est pas non plus utile d importer «java.lang» car cette importation est réalisée automatiquement; ce paquetage est tellement fondamental qu aucune application java ne pourrait s exécuter sans son concours Les hiérarchies de paquetages Pour organiser les classes, nous regrouperons ces dernières en paquetages qui eux mêmes pourront contenir d autres paquetages plus spécialisés et ainsi de suite. Nous réaliserons ainsi une hiérarchie de paquetages à la manière des hiérarchies de répertoires dans les systèmes de fichiers. L importation d une class Xxx située dans le sous-paquetage Bbb du paquetage Aaa s écrira ainsi, en explicitant le chemin d accès: 1 Dans la mesure où les identificateurs des divers packages utilisés peuvent être différenciés!

16 import Aaa.Bbb.Xxx ; Relations avec le système de gestion de fichiers Une des caractéristiques avantageuses des paquetages est qu ils permettent aussi, par effet de bord, de dissimuler la syntaxe des noms de fichiers dans le cadre de Java; rappelons que Java devrait être aussi indépendent du système que possible; idéalement, la syntaxe des noms de fichiers utilisée ne doit pas transparaître dans le langage. Il existe néanmoins une correspondance rigide entre les dénominations de classes et de paquetages et les noms de fichiers utilisés. Ceci implique qu un portage de classes Java d un ordinateur sur un autre peut éventuellement poser quelques problèmes de configuration de l environnement de développement Java utilisé. Règles.. On a déjà mentionné auparavant la relation existant entre la classe publique d un ensemble de classes résidant dans un fichier et le nom de ce fichier : la classe et le fichier portent le même nom, à l extension «.java» près. Les paquetages obéissent à une règle similaire. Chaque paquetage est en principe placé dans son propre répertoire, dont le nom correspond à celui du paquetage, dans la mesure où le système de fichiers local peut s accommoder du nom du paquetage. Dans les environnements de type PC (Windows 95, Windows 98, NT), on définit la variable d environnement CLASSPATH qui détermine la racine de l arborescence dans laquelle sont situés les paquetages. Ainsi, une hiérarchie de paquetages devra en principe mise en place en élaborant une hiérarchie correspondante de répertoires dans le système de fichiers. 2.2 Structure d une application Java Comme une application Java peut contenir un nombre relativement énorme de classes, l outil naturel qui s offre au programmeur et d organiser ces classes au sein d une hiérarchie de paquetages : nous trouverons dans un même paquetage toutes les classes qui collaborent à une même fonctionnalité. Chaque paquetage sera placé dans un répertoire du système de fichiers, répertoire qui portera le même nom que le paquetage lui-même. Composition d un paquetage Les classes et les interfaces qui composeront le paquetage seront écrites dans des fichiers portant l extension «.java». Ces fichiers seront tous placés dans le même répertoire, celui du paquetage.

17 Composition d un fichier En général, chaque fichier contiendra une seule classe (ou une seule interface) qui sera déclarée avec le mot-clé «public» si cette dernière doit pouvoir être utilisée en dehors du paquetage. Si le mot «public» n est pas mentionné, cette classe (ou interface) ne sera visible qu à l intérieur du paquetage. Un fichier peut contenir un nombre indéterminé de classes et d interfaces! En principe, dans la philosophie Java, le rôle du fichier est de mettre à disposition une classe ou une interface qui sera utilisée par les autres composants de l application. Il est possible toutefois que la mise en oeuvre de cette classe (ou interface) que l on appellera le «composant principal», nécessite l écriture d autres classes ou interfaces. Ces autres composants, que l on appellera «composants secondaires», seront écrits dans le seul but de prendre en charge une partie du travail. Le programmeur pourra les placer naturellement dans le même fichier. Un seul composant «public» par fichier! Les «composants secondaires», nécessaires à la mise en oeuvre du composant principal, ne seront jamais visibles en dehors du paquetage. En effet, Java impose que chaque fichier ne contienne qu un seul élément exportable, désigné par le motclé «public». Le nom du fichier devra correspondre exactement au nom du composant principal, accompagné de l extension «.java». Amorce de l application Parmi les classes publiques, une au moins comportera une fonction «main» qui sera invoquée au moment du lancement du programme : java Xxx exécution de la machine virtuelle Java, qui invoque la fonction «main» de la classe «Xxx» (qui doit être une classe publique). 2.3 Librairies de packages Les principaux packages La librairie de base Java est divisée en un certain nombre de packages:

18 «java.lang» comprend les éléments fondamentaux de la librairie. Aucune application Java ne peut s exécuter sans cette librairie. Par conséquent, elle est importée d office, sans qu il soit nécessaire de spécifier son importation au moyen du mot réservé «import». «java.applet» définit la notion d applet, sur laquelle nous reviendrons plus tard. «java.awt» définit le système de fenêtrage indépendant de la machine, l Abstract Window Toolkit. Internet. «java.io» réalise les entrées-sorties sur fichiers. «java.net» permet des opérations de bas niveau sur le réseau «java.util» est une boîte à outils implémentant des mécanismes généraux extrêmement utiles. Cet ensemble représente le plus petit commun dénominateur entre deux implémentations de Java. Ces classes se servent d un nombre limité de classes élémentaires pour communiquer entre elles. Le type de base «Object» est défini à ce niveau. «java.lang» et l emballage de types primitifs Un problème déjà mentionné plus haut est que Java ne désigne pas TOUT par des références. Les types primitifs (voir le chapitre [Types de Java]) forment une exception à ce mécanisme, ce qui peut poser quelques problèmes. Pour y suppléer, le package «java.lang» définit, pour tout type primitif, une classe correspondante, appelée class wrapper (emballage de classe). Type primitif boolean char double float int long Classe correspondante Boolean Character Double Float Integer Long Ces classes possèdent également un certain nombre de méthodes propres permettant de manipuler plus facilement les objets. Ainsi, la classe «Integer» possède une méthode «parseint(string)» qui permet la conversion d une chaîne de caractères (UniCode) en un string, ainsi que la méthode «tostring» qui réalise l opération inverse. Un bref aperçu de «java.util» «java.util» est un autre package très utilisé, mais son importation, contrairement à celle de «java.lang», n est pas implicite. Parmi les nombreuses classes implémentées par «java.util», citons «Vector», qui est un tableau générique sans dimensions prédéfinies, et qui s étend automatiquement selon les besoins de l utilisateur.

19 «java.util» contient des classes de bas niveau, implémentant des mécanismes élémentaires, et des fonctionnalités de base, telle que l interrogation de la date et de l heure. Il est probablement indispensable à n importe quel applet ou application non triviale. Nous reviendrons par la suite sur ce package de manière plus exhaustive, dans un chapitre y consacré.

20 - 20 -

21 Classes et objets Cette section présente de «classes» et «d'objets», telles que Java les appréhende. Si l aspect syntaxique est privilégié, sont abordés un certain nombre de sujets à caractère fondamental comme la copie d objets et le cycle de vie d un objet. 3.1 Généralités Les objets sont les acteurs principaux d'un programme écrit en Java. Leur rôle principal consiste à emmagasiner des informations et à mettre à disposition une collection d opérations qui permettent d'accéder à ces informations et le cas échéant de les modifier. Chaque objet est «l'instance» d'une classe. C est la classe qui spécifie le type des informations qui seront emmagasinées par l'objet, et qui spécifie également les opérations qui peuvent agir sur ces informations. En particulier : Les informations sont emmagasinées dans les objets sous la forme de variables d'instance (que l'on appelle aussi «champs»). C'est dans la classe de l'objet que doivent être spécifiées ces variables d'instances. Ces variables d'instance peuvent être soit des types de base (c'est-à-dire des entiers, des réels, des booléens ou des caractères), types de base que l on appelle encore t y p e s p r i m i t i f s ou types intrinsèques, soit des références à des objets d'autres classes.

22 Les opérations qui permettent d'agir sur les objets sont appelées des m é t h o d e s. Ces méthodes définissent le comportement qui caractérise tous les objets définis comme des instance de cette classe. On trouve trois types de méthodes : les contructeurs, les procédures et les f o n c t i o n s. Le ou les constructeurs seront invoqués automatiquement, au moment de la création de l objet par le biais de l opérateur «new». Les procédures et fonctions seront invoquées en envoyant à l'objet le message correspondant. Comme dans tous les langages orientés objet, une classe de Java peut hériter des informations et des méthodes définies dans une autre classe Java. Dans ce cas, on dit que la classe qui h é r i t e ou d é r i v e de cette autre classe. Cette autre classe s'appelle par définition la superclasse de la classe qui en hérite. Contrairement à C++ - qui supporte l'héritage multiple -, une classe Java ne peut hériter que d'une seule classe à la fois. Toute classe Java hérite obligatoirement d'une autre classe. Tout en haut de la hiérarchie, on trouve la superclasse «Objet» dont hérite toutes les classe Java (directement ou indirectement). Notamment, si on omet le motclé «extends» lors de la déclaration d'une classe, le compilateur Java assume que la nouvelle classe hérite directement de la classe «Object». Java propose une forme limitée de l'héritage multiple, par le biais du concept «d'interface». A défaut d héritage multiple, on peut parler en Java de typage multiple. Expliquons-nous.. Une interface est un «mode d emploi», composée essentiellement d une collection de méthodes. Ces méthodes sont vides, présentées uniquement par leur signature (entête). Une interface ne comprend aucune variable d instance. Ainsi, une interface Java définit en quelque sorte une espèce de type abstrait, c est-à-dire un type de données décrit uniquement par les opérations qui le caractérisent. Une interface ne permet pas de créer des objets, seules les classes sont prévues à cet effet. Par contre, une classe à la possibilité d implémenter une, voire plusieurs, interface(s) en proposant un corps (des instructions) pour chacune des méthodes énoncées dans le ou les interfaces concernés. Tout objet créé à partir d une telle classe se caractérise ainsi par un «typage multiple» : le type de la classe dont il est issu, mais aussi le type de chacunes des interfaces implémentées par la classe en question. La notion d interface est très puissante. Notamment, grâce à cette notion, le programmeur a la possibilité d'écrire des méthodes très générales en spécifiant des paramètres formels de type interface plutôt que de type classe. Si le paramètre formel est de type interface, cela signifie simplement que la classe du paramètre effectif peut être tout à fait quelconque, pour autant qu elle «implémente» les fonctionnalités spécifiées dans cette interface. Vu que les méthodes d'une interface sont vides, le problème de l'ambiguïté que l'on rencontre en C++ avec l'héritage multiple n'existe pas en Java : les multiples interfaces implémentées par une classe peuvent avoir des méthodes en commun, mais il ne s agit que de signatures de méthodes. A l exécution, le corps de la méthode exécutée sera celui de la classe, et il est unique.

23 Comment déclarer une classe La déclaration d'une classe obéit à la syntaxe suivante : [<modificateurs_de_classe>] class <nom_de_classe> [extends <nom_de_superclasse>] [implements <interface_1>,<interface_2,...] { <Méthodes_et_Variables> Dans la syntaxe que nous utilisons pour définir les éléments de Java, les options sont marquées dans une paire de crochets droits («[» «]»), les mot-clés sont marqués en gras, et les identificateurs dans une paire de crochets anguleux («<» «>»). Un exemple.. abstract class CreatureMythique extends Creature { // Variables d'instance protected int age ; // Age de la créature protected String nom ; // Nom de la créature boolean estmagique ; // Indique l'existence // de pouvoirs magiques // Constructeurs public CreatureMythique () { // Corps (instructions) du constructeur sans paramètre // Initialisation des variables d'instance age = 0 ; nom = "Anonyme"; estmagique = false; public CreatureMythique (String monnom, int monage, boolean magique) { // Corps d'un constructeur avec paramètres // Initialisation des variables d'instance age = monage ; nom = monnom ; estmagique = magique; // Méthodes diverses public abstract void fairedelamagie();// Méthode abstraite public int get_age () { // Corps de la fonction return age;

24 Dans cet exemple, nous avons utilisé un modificateur de classe: le mot-clé «abstract». Nous avons défini 3 variables d'instance et 4 méthodes, dont deux constructeurs, une procédure (sans type retourné) et une fonction (retournant un entier). Notons que la définition de la classe commence par une accolade «{» et se termine par une accolade. Le mot-clé «extends» indique que la classe hérite de la classe «Creature». Grâce à cet héritage, toutes les opérations applicables aux objets de la classe «Creature» s'appliquent automatiquement aux objets de la classe «CreatureMythique». Les modificateurs de classe Les modificateurs de classe sont des mot-clés optionnels qui précèdent le mot-clé «class». Ces modificateurs spécifient la portée ainsi que le statut de la classe au sein du programme. Le langage prévoit 3 modificateurs de classe : «abstract» «final» et «public» : Le modificateur «public» annonce que cette classe peut être utilisée - notamment instanciée ou héritée - partout dans le même «paquetage» («package») ou alors dans tout autre paquetage qui «importerait» cette classe. Pour plus de détails, le lecteur est renvoyé au chapitre [Paquetages]. Toute classe publique doit être déclarée dans son proche fichier qui doit porter obligatoirement le nom de la classe publique : <nom_de_la_classe>.java. Un fichier ne peut contenir qu'une seule classe publique. Un paquetage peut être composé de plusieurs fichiers. Si le mot-clé «public» n'est pas utilisé, le mode «package» est sous-entendu : la classe est considérée simplement comme une «classe amie», qui ne peut être utilisée qu'à l'intérieur du même paquetage, mais qui ne peut être utilisée ailleurs, même par le biais d'une importation. Le modificateur «abstract» annonce qu'il s'agit d'une «classe abstraite», c'est-à-dire une classe qui contient des «méthodes abstraites». Les classes abstraites sont décrites en détail dans le paragraphe [Classe et objets : Les classes abstraites]. Le modificateur «final» annonce que la classe ne peut pas avoir de «sous-classes»: aucune classe peut en hériter à des fins de spécialisation. Les classes abstraites sont décrites en détail dans le paragraphe [4 : Héritage et polymorphisme ]. Héritage : le mot-clé «extends» Ce mot-clé est optionnel. Prenons l'exemple de la classe «CreatureMythique»: abstract class CreatureMythique extends Creature {..

25 Le mot-clé «extends» indique que la classe «CreatureMythique» hérite de la classe «Creature». Il en découle deux propriétés : 1) Toutes les opérations applicables aux objets de la classe «Creature» sont également applicables aux objets de la classe «CreatureMythique», 2) Tous les éléments de la classe «Creature» qui n'ont pas été déclarés privés («private») peuvent être manipulés directement par les méthodes de la classe «CreatureMythique». Par héritage successif, il est possible de définir une hiérarchie d'héritage. Si une classe «X» hérite d'une classe «Y», ont dit que «X» est la sousclasse de «Y», et que «Y» est la superclasse de «X». Si le programmeur omet le mot-clé «extends» lors de la déclaration d'une classe, le compilateur Java assume que la nouvelle classe hérite directement de la classe «Object». Tout en haut de la hiérarchie, on trouve donc la superclasse «Objet» dont hérite toutes les classe Java. Pour trouver des informations plus détaillées concernant le concept d'héritage : son utilité et la manière de s'en servir, nous renvoyons le lecteur au paragraphe [ 4 :Héritage et polymorphisme ]. Implémentation d interface : le mot-clé «implements» Ce mot-clé est optionnel. Une classe peut «implémenter» une «interface», voire même plusieurs... Qu'est-ce qu'une interface? Cette notion est spécifique à Java. Dans le cadre de ce chapitre, nous nous limiterons à un aperçu très général. Le lecteur est renvoyé au chapitre [5 Interfaces] pour obtenir plus de détails. Une interface est une spécification qui permet de définir un nouveau type de données. Il s'agira d'un type de données abstrait, définit uniquement par la liste des opérations qui pourront lui être appliqués. Voici par exemple la définition de l'interface «Runnable»: interface Runnable { public void run() ;// Entête de la procédure "run" Cette définition implique que tout objet de type «Runnable» est susceptible de répondre au message «run». En l occurrence, les objets de type «Runnable» sont des o b j e t s a c t i f s, caractérisés par un flot d'exécution concurrent au reste du programme. La méthode «run» qui les caractérise contient le code de l'activité concurrente.

26 Considérons maintenant l'exemple d'une applet décrivant un objet actif : public class MaClasse extends java.applet.applet implements Runnable { : Thread runner; // activité concurrente public void start ( ) { // crée et démarre le thread if ( runner == null ) { runner = new Thread (this); // le paramètre du constructeur de la classe // "Thread" doit être de type "Runnable". // Ce paramètre indique un objet, dont la // méthode "run" sera exécutée par l'activité // concurrente. Dans notre cas, le paramètre "this" // indique que la méthode "run" exécutée sera celle de // la classe «MaClasse» runner.start ( ); public void run ( ) { // cette méthode contient le code de l'activité concurrente : public void stop { if ( runner!= null ) { runner.stop ( ); runner = null; Cette classe est acceptée par le compilateur. En effet, ce dernier a trouvé l'implémentation de la méthode «run» conformément à l'annonce d'implémentation indiquée dans l'entête de la classe. La notion d'interface permet le typage multiple. Dans l'exemple ci-dessus, on peut considérer que tout objet de type «MaClasse» est caractérisé par 3 types : il est d'abord de type «MaClasse», mais il est aussi de type «Applet» (par héritage), et il est encore de type «Runnable» (par implémentation d'interface). Un tel objet peut être passé comme paramètre effectif à chaque fois que le type attendu correspond à l'un ou l'autre de ces 3 types. Vu que les méthodes d'une interface sont vides, le problème de l'ambiguïté que l'on rencontre en C++ avec l'héritage multiple n'existe pas en Java : les multiples interfaces implémentées par une classe peuvent avoir des méthodes en commun, mais il ne s agit que de signatures de méthodes. A l exécution, le corps de la méthode exécutée sera celui de la classe, et il est unique.

27 Variables d'instance Une classe Java spécifie le type des informations qui seront emmagasinées par les objets. Ces informations sont définies par le biais de «variables d'instance». Syntaxe à suivre pour déclarer une variable d'instance : [<modificateurs_de_variable>] <type> <nom> [ = <valeur_initiale>] ; Voici quelques exemples de variables d'instance pour la classe «Gnome» : class Gnome extends CreatureMythique { // Variables d'instance protected Gnome copain ; // Copain du gnome (un autre gnome..) protected int taille = 1; // Taille du gnome // Variable de classe public static final int HAUTEUR_MAX = 3 ;// Une constante // Méthodes.... Quelques remarques sur cet exemple : la variable «copain» est de type «Gnome», un «type objet» ; la variable «taille» est un entier, les entiers font partie des «types de base», que l'on appelle encore «types primitifs» ; la variable «HAUTEUR_MAX» est une constante de type entier. Cette variable n'est pas une variable de d'instance : il s'agit plutôt d'une variable de classe. En effet, sa déclaration contient deux <modificateur_de_variable> : 1) le mot-clé «static» indique qu'il s'agit d'une variable de classe. De telles variables n'existent qu'en un seul exemplaire : elles sont partagées par toutes les instances. Par exemple, il est possible d'utiliser une variable de classe pour compter les instances. En général, les constantes sont implémentées de cette manière, au moyen de variables de classe. Les «variables de classe» sont décrites de manière plus détaillée dans [3.4 Variables de classe]. 2) le mot-clé «final» indique qu'il s'agit d'une constante : sa valeur n'est pas modifiable, elle est définie une fois pour toutes.

28 Type d'une variable d'instance Une variable d'instance doit avoir un <type>. Ce type peut être soit : un type primitif (un entier, un réel, un booléen ou un caractère). Dans ce cas, la variable contient directement la valeur du type de base. ou alors un type objet, dont le nom désigne celui d'une classe ou éventuellement d une interface. Dans ce cas, la variable ne contient pas la valeur de l'objet. La variable est une adresse mémoire (une «référence», un «pointeur»), qui «réfère» l'objet. Figure 1 Types primitifs et types objet int x = 3; // x est un "type primitif", // x contient la valeur "3" x 3 Point x = new Point (2, 3); // x est un type objet // x est une référence sur l'objet x 2 3 un point Nom d'une variable d'instance Le <nom> de la variable est un identificateur. Un identificateur doit commencer par une lettre. Les autres caractères peuvent être soit des lettres, soit des chiffres appartenant au jeu de caractères «Unicode». Valeur initiale d'une variable d'instance La syntaxe de la <valeur_initiale> - optionnelle -, est telle que cette valeur doit être du même type que le <type> déclaré de la variable. Portée des variables : «public», «private» et «protected» La portée 2 des variables d'instance peut être contrôlée par le biais des modificateurs de variables. Notons en préliminaire que la portée d une variable s étend à toute la classe, dans laquelle elle est déclarée. Au sein d une même classe, une variable est donc accessible par toutes les méthodes déclarées avant la déclaration de la variable elle-même. 2 La «portée» d'un élément désigne tous les endroits du programme où il est possible d'accéder et de manipuler à cet élément

29 Java propose 5 modificateurs de variable. Les 3 premiers ( «public», «private» et «protected») sont des modificateurs de portée. Ils sont exclusifs : ils ne peuvent pas être cumulés ; on doit ainsi utiliser soit l'un soit l'autre. Pour une informations plus détaillée sur ces 3 modes, leur utilité, se reporter à [4.6 Un bilan sur les modes de protection] le modificateur «public» indique qu'il n'y a pas de restriction d'accès : la variable est visible, accessible en Lecture/Ecriture par les méthodes de toutes les classes. le modificateur «private» indique que la variable est interne à la classe: elle est visible, accessible en Lecture/Ecriture, uniquement par toutes les méthodes de la classe. le modificateur «protected» est une variante du mode «private», il indique que l accès à la variable est autorisé en Lecture/Ecriture : 1) Par toutes les méthodes des classes dérivées. L accès est toutefois limité à la variable de l instance même pour laquelle la méthode s exécute : this.nomvariable =... ; 2) Mais aussi par toutes les méthodes des classes «amies» du même p a q u e t a g e. par défaut, si aucun des 3 modificateurs décrits ci-dessus n'est utilisé, c'est le mode «package» qui est sous-entendu. Ce mode indique que la visibilité de la variable, en Lecture/Ecriture, est limitée aux classes du paquetage courant. Les modificateurs «static» et «final» Ces 2 derniers modificateurs ont un usage différent. Ils sont cumulables aux 3 premiers modificateurs (voir notamment la variable «HAUTEUR_MAX» de l'exemple ci-dessus). le modificateur «static» indique que la variable est associée non pas aux instances de la classe, mais à la classe elle-même. Une telle variable s'appelle une «variable de classe». Voir [3.4 Variables de classe] pour toutes les informations relatives à ce sujet. le modificateur «final» désigne une «constante» : une variable dont la valeur est définie une fois pour toutes. La déclaration d'une telle variable doit comporter une <valeur_initiale>. Par la suite, cette valeur ne peut pas être modifiée, elle sera accessible uniquement en lecture. S'il s'agit d'un type primitif (entier, réel, bouléen, caractère), il s'agit d'une constante à proprement parler. S'il s'agit au contraire d'un objet (une «référence» sur un objet), cela signifie que cette variable doit toujours référencer le même objet, même si la valeur de l'objet lui-même est susceptible de changer. Quelques exemples : // Une variable de classe constante

30 public static final int HAUTEUR_MAX = 3 ; // Deux variables d'instance constantes final float PI = f ; final int TAILLE_MAX = ; Par convention d'écriture, on écrit le nom des constantes en majuscule. Masquage d'une variable d'instance Au contraire des méthodes, une variable d'instance ne peut pas être redéfinie par une sousclasse. Cependant il est toujours possible de déclarer dans une sousclasse un attribut qui aurait le même nom qu'un attribut public ou protégé défini plus haut, dans une superclasse. Dans ce cas, l'attribut défini au niveau de la superclasse continue d'exister, mais il n'est plus possible d'y accéder en utilisant simplement son nom : on dit que l'attribut est masqué. Il est possible toutefois d'accéder à l'attribut de la superclasse en utilisant le mot-clé «super», comme par exemple : super.nomattribut = 10 ; En Java, le masquage des attributs est autorisé afin que les implémenteurs des superclasses soient libres d'y ajouter de nouveaux champs publics ou protégés sans casser les sous-classes qui utiliseraient déjà ces noms. 3.4 Variables de classe Les variables de classe sont utilisées pour mémoriser des informations globales qui concernent la classe elle-même. Une variable de classe est introduite par le mot-clé «static». A titre d'illustration, considérons la classe «Gnome» qui comporte une variable de classe : la variable «HAUTEUR_MAX». class Gnome extends CreatureMythique { // Variables d'instance protected Gnome copain ; // Copain du gnome (un autre gnome..) protected int taille = 1; // Taille du gnome // Variable de classe public static final int HAUTEUR_MAX = 3 ; // Une constante // Méthodes.... La variable «HAUTEUR_MAX» existe en un seul exemplaire, au niveau de la classe «Gnome», et elle est partagée par tous les objets «Gnome» créés par instanciation.

31 Les variables de classe existent même si aucune instance de la classe n'a été créée. Un exemple.. Voici une classe qui compte ses instances : à chaque création d'objet, le constructeur, qui est invoqué automatiquement, incrémente la variable d'instance «nombredinstances». public class MesInstancesSontComptees { // Variable de classe comptant le nombre d'instances private static int nombredinstances = 0; // Constructeur MesInstancesSontComptees () { nombredinstances++ ; // incrémente le compteur à chaque // création d'instance // Autres méthodes public static int nbinstances () { // méthode d'accès à la variable de classe return nombredinstances; Utilisation : MesInstancesSontComptees o1, o2 ; o1 = new MesInstancesSontComptees() ; o2 = new MesInstancesSontComptees() ; System.out.println (MesInstancesSontComptees.nbInstances()) ; Affiche «2» Les variables de classe sont en général manipulées par les «méthodes de classe». Aussi, pour trouver des informations à ce sujet, le lecteur est renvoyé à [Classes et objets : Les méthodes : Les méthodes de classe et les méthodes d'instance]. Initialisation d'une variable de classe De manière identique aux variables d'instance, la déclaration d'une variable de classe peut comporter un «initialiseur» : static public int v = 10 ; Cette initialisation aura lieu au moment du «chargement de la classe», c'est à dire dès l'instant que la classe est utilisée. Le constructeur de classe Par ailleurs, l'équivalent du «constructeur» existe pour les variables de classe.

32 Un tel constructeur est désigné par le mot-clé «static». Ce constructeur sera invoqué au moment du chargement de la classe. Comme ci-après : static { : v = 20 ; // Initialisation d'une variable de classe : A l'instar des méthodes de classe (voir plus loin), le constructeur de classe ne peut accéder qu'aux variables de classe. L'accès aux variables d'instance (informations propres aux objets) lui est interdit. 3.5 Les méthodes Nous décrirons les méthodes en commençant par un aperçu général qui, dans une première approche, peut être suffisant. Les formalistes trouveront leur compte en lisant la deuxième partie, consacrée plus particulièrement à la syntaxe Aperçu général Les méthodes de Java sont similaires aux fonctions et aux procédures que l'on rencontre dans les langages habituels. Il s'agit en général de blocs d'instructions qui seront exécutées en agissant sur un objet particulier. L'exécution d'une méthode résulte d'un envoi de message à l'objet. Par exemple, l'instruction suivante : «unpoint.déplacer (10, 15);» a pour effet d'envoyer le message «déplacer(..)» à l'objet «unpoint» de type «Point». Les instructions de la méthode «déplacer(..)» (une procédure) sont alors exécutées. Les méthodes peuvent accepter des paramètres. Leur comportement dépendra donc d'une part de l'objet sur lequel on leur demande d'agir et d'autre part de la valeur des paramètres passés lors de l'envoi du message. Toutes les méthodes de Java seront déclarées à l'intérieur d'une classe. Le concept de méthode «libre», détachée de toute classe, n'existe pas en Java (contrairement à C++). La définition d'une méthode comporte deux parties : L'entête, qui définit le nom de la méthode et la liste des paramètres ; Le corps («body»), qui contient les instructions de la méthode Signature d une méthode Par définition, la signature d'une méthode comprend son nom et ses paramètres, mais ne comprend pas le type retourné. Dans le cadre de ce manuel, nous désignons par le terme entête l ensemble «signature + type retourné».

33 Déclaration d'une méthode La déclaration d'une méthode obéit à la syntaxe suivante décrite ci-dessous, qui sera détaillée dans ce qui suit : [<modificateurs_de_méthode>] <type_retourné> <nom_méthode> ([<paramètres>]) [<exceptions>] { <corps_de_la_méthode> Nom d'une méthode Le <nom> de la méthode obéit à la syntaxe générale des identificateurs : un identificateur doit commencer par une lettre. Les autres caractères peuvent être soit des lettres, soit des chiffres appartenant au jeu de caractères «Unicode» Distinguer les procédures des fonctions Prenons l'exemple de la classe «Gnome». class Gnome extends CreatureMythique { // Variables d'instance protected int taille = 1; // Taille du gnome : // Quelques méthodes... public void renommergnome (String s) { // Une procédure pour modifier le nom d'un gnome nom = s ; // nom est une variable d'instance héritée public int get_taille () { // Une fonction pour retourner la taille d'un gnome return taille ; : On distingue deux catégories de méthodes : les procédures et les f o n c t i o n s. Les procédures ne retournent aucune valeur. L'entête d'une procédure comporte le mot-clé «void», qui signifie qu'elle ne retourne «rien». La méthode «renommergnome» est une procédure. valeur. Au contraire des procédures, les fonctions retournent toujours une La méthode «get_taille» est une fonction. Voici un autre exemple de fonction : public boolean estadulte () {

34 return age > 17 ; Pour retourner sa valeur, une fonction doit utiliser l'instruction «return» dont la syntaxe est la suivante : return <expression> ; Le type de l'expression doit obligatoirement correspondre au <type_retourné> déclaré dans l'entête de la fonction («boolean» dans notre exemple). Une fonction ne peut retourner qu'une seule valeur Invoquer une méthode : l'envoi de message L'exécution d'une méthode résulte d'un «envoi de message» à un objet. Gnome ungnome = new Gnome(); // Déclaration et création de l'objet «ungnome» ungnome.renommergnome ("Alfred"); // Envoi du message «renommergnome» à l'objet int sataille = ungnome.get_taille () ; // Envoi du message «get_taille» au même objet Syntaxe d'un envoi de message : <référence_objet>.<nom_méthode> ( [<paramètre>, <paramètre>,..]) La <référence_objet> correspond au nom de la variable utilisée pour désigner l'objet. Pour plus d'informations à ce sujet, le lecteur est renvoyé à [7.2.4 L opérateur «.» : envoi de message, accès aux variables d un objet] Cas particulier des «méthodes de classe» : Nous verrons un peu plus loin que les méthodes se divisent en deux catégories : les méthodes d'instance et les méthodes de classe. Les méthode de classes ont ceci de particulier qu'elles sont invoquées en envoyant le message à la classe elle-même, plutôt qu'à une instance de cette classe. Par exemple, les fonctions «sinus» et «racine carrée» sont des méthodes de classe de la classe «Math». Voici des exemples d'invocation : float f = Math.sin (x); // "sin" est une méthode de classe, ainsi que «sqrt» float root = Math.sprt (453.0);