Beaudouin-Lafon Les Langages à Objets (Armand Colin)

download Beaudouin-Lafon Les Langages à Objets (Armand Colin)

of 161

Transcript of Beaudouin-Lafon Les Langages à Objets (Armand Colin)

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    1/161

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    2/161

    LES LANGAGES OBJETSPrincipes de base,techniques de programmation

    Michel Beaudouin-Lafon

    Armand Colin 1992

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    3/161

    Table des matires

    Chapitre 1 - INTRODUCTION .................................. ............1

    1.1 Le champ des langages................ ...............................1

    1.2 Historique...................................................................8

    1.3 Plan du livre ..................................... ........................12

    Chapitre 2 - PRINCIPES DE BASE......................................13

    2.1 Classes et instances....................................................14

    2.2 Mthodes et envoi de message ............................... ...172.3 Lhritage ................................................................18

    2.4 Lhritage multiple...................................................22

    2.5 Le polymorphisme ...................................................24

    2.6 Les mtaclasses.................................. .......................28

    Chapitre 3 - LANGAGES OBJETS TYPS.......................31

    3.1 Classes, objets, mthodes...........................................33

    3.2 Hritage....................................................................39

    3.3 Hritage multiple................ ......................................44

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    4/161

    3.4 Liaison dynamique...................................................483.5 Rgles de visibilit ................................... .................52

    3.6 Mcanismes spcifiques..................... .......................56

    3.7 Conclusion ...............................................................60

    Chapitre 4 - SMALLTALK ET SES DRIVS....................61

    4.1 Tout est objet............................................................64

    4.2 Classes, instances, messages.......................................65

    4.3 Hritage....................................................................69

    4.4 Les structures de contrle ....................................... ..74

    4.5 Mtaclasses............................... ................................81

    4.6 Les drivs de Smalltalk............................................87

    4.7 Conclusion ...............................................................92

    Chapitre 5 - PROTOTYPES ET ACTEURS..........................93

    5.1 Langages de prototypes............................................93

    5.2 Langages dacteurs.................................................104

    Chapitre 6 - PROGRAMMER AVEC DES OBJETS ..... ..... .117

    6.1 Identifier les classes ........................................ ........118

    6.2 Dfinir les mthodes.......................... .....................125

    6.3 Rutiliser les classes ........................................ ........132

    6.4 Exemple : les Tours de Hanoi........ .........................136

    6.5 Conclusion .............................................................140

    Bibliographie.....................................................................141

    Index.................................................................................145

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    5/161

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    6/161

    Avant-propos

    Ce livre a pour objectif de prsenter les langages objets et laprogrammation par objets d'une manire gnrale et nanmoinsprcise. Le nombre de langages objets existant aujourd'hui etleur diversit interdisent une tude exhaustive dans un ouvragede cette taille. C'est pourquoi l'on s'est attach identifier unnombre rduit de concepts de base, partags par de nombreuxlangages, et illustrer ces concepts par des exemples concrets. Ilne s'agit donc pas d'apprendre programmer avec un langage objets (d'autres ouvrages, spcialiss, s'y emploient), mais dematriser les principes de ces langages et les techniques de la

    programmation par objets.Ce livre s'adresse des lecteurs ayant une exprience de la

    programmation avec des langages classiques comme Pascal etLisp, ou tout au moins une connaissance des principes de ceslangages. Il s'adresse donc tout particulirement des tudiantsde second et troisime cycle d'Informatique, ou d'autresdisciplines dans lesquelles la formation l'Informatique abordeles langages de programmation volus. Ce livre s'adressegalement aux lves des coles d'ingnieurs, aux chercheurs,aux enseignants, et plus gnralement tous ceux qui veulentcomprendre les langages objets.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    7/161

    Plusieurs annes d'enseignement des langages objets auD.E.S.S. Systme et Communication Homme-Machine del'Universit de Paris-Sud, et des confrences au Certificat C4d'Informatique Applique de cette mme Universit, m'ontconduit la prsentation des langages objets adopte dans celivre : dans les deux cas, le faible volume horaire interdit toutapprentissage d'un langage particulier et invite uneprsentation synthtique. Il en rsulte une grille d'analyse deslangages objets, largement maille d'exemples, dontl'ambition est de permettre au lecteur d'aborder la program-mation avec un langage objets avec une vision claire et sainede l'univers de ces langages.

    Plusieurs personnes ont contribu rendre ce livre plus clairet, je l'espre, facile d'accs : Thomas Baudel, Jean Chassain,Stphane Chatty, Marc Durocher, Solange Karsenty ont relu desversions prliminaires de cet ouvrage et apport des commen-taires constructifs ; les membres du groupe Interfaces Homme-Machine du Laboratoire de Recherche en Informatique, par leurexprience quotidienne de la programmation par objets, ontpermis tout la fois de mettre en vidence les ralits pratiquesde l'utilisation des langages objets et de mettre l'preuve uncertain nombre d'ides prsentes dans ce livre. Marie-ClaudeGaudel a galement contribu clarifier les notions lies autypage dans les langages de programmation en gnral et dansles langages objets en particulier. Enfin, mon frre Emmanuela ralis l'ensemble des figures de cet ouvrage, et je lui en suisinfiniment reconnaissant.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    8/161

    Chapitre 1

    INTRODUCTION

    Les langages objets sont apparus depuis quelques annescomme un nouveau mode de programmation. Pourtant laprogrammation par objets date du milieu des annes 60 avecSimula, un langage cr par Ole Dahl et Kristen Nygaard enNorvge et destin programmer des simulations de processusphysiques. Bien que de nombreux travaux de recherche aient

    eu lieu depuis cette poque, lessor des langages objets estbeaucoup plus rcent. Ce livre essaie de montrer que leslangages objets ne sont pas une mode passagre, et que laprogrammation par objets est une approche gnrale de laprogrammation qui offre de nombreux avantages.

    1.1 LE CHAMP DES LANGAGES

    Situer les langages objets dans le vaste champ des langagesde programmation nest pas chose facile tant le terme dobjetrecouvre de concepts diffrents selon les contextes. Nousprsentons ici plusieurs classifications des langages et situons les

    langages objets dans ces diffrentes dimensions.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    9/161

    2 Les langages objets

    Classification selon le mode de programmation

    Cette classification prsente les principaux modles deprogrammation qui sont utiliss aujourdhui, cest--dire lesprincipaux modles par lesquels on peut exprimer un calcul.

    La programmation imprative, la plus ancienne, correspondaux langages dans lesquels lalgorithme de calcul est dcritexplicitement, laide dinstructions telles que laffectation, letest, les branchements, etc. Pour sexcuter, cet algorithmencessite des donnes, stockes dans des variables auxquellesle programme accde et quil peut modifier. La formule deNiklaus Wirth dcrit parfaitement cette catgorie de langages :

    programme = algorithme + structure de donnes.

    On classe dans cette catgorie les langages dassemblage,Fortran, Algol, Pascal, C, Ada. Cette catgorie de langages estla plus ancienne car elle correspond naturellement au modledarchitecture des machines qui est la base des ordinateurs :le modle de Von Neumann.

    La programmation fonctionnelle adopte une approchebeaucoup plus mathmatique de la programmation. Fondesur des travaux assez anciens sur le lambda-calcul etpopularise par le langage Lisp, la programmationfonctionnelle supprime la notion de variable, et dcrit un

    calcul par une fonction qui sapplique sur des donnesdentres et fournit comme rsultat les donnes en sortie. Defait, ce type de programmation est plus abstrait car il fautdcrire lalgorithme indpendamment des donnes. Il existepeu de langages purement fonctionnels ; beaucoup intro-duisent la notion de variable pour des raisons le plus souventpratiques, car labstraction complte des donnes conduitsouvent des programmes lourds crire. Parmi les langagesfonctionnels, il faut citer bien sr Lisp et ses multiplesincarnations (CommonLisp, Scheme, Le_Lisp, etc.), ainsi queML.

    La programmation logique, ne dune approche galementlie aux mathmatiques, la logique formelle, est fonde sur la

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    10/161

    Introduction 3

    description dun programme sous forme de prdicats. Cesprdicats sont des rgles qui rgissent le problme dcrit ;lexcution du programme, grce linfrence logique,permet de dduire de nouvelles formules, ou de dterminer siune formule donne est vraie ou fausse partir des prdicatsdonns. Linfrence logique est tout fait similaire auxprincipes qui rgissent la dmonstration dun thormemathmatique laide daxiomes et de thormes connus. Leplus clbre des langages logiques est Prolog.

    La programmation par objets est-elle une nouvelle catgoriedans cette classification ? Il est difficile de rpondre cettequestion. La programmation par objets est proche de la

    programmation imprative : en effet, l o la programmationimprative met laccent sur la partie algorithmique de laformule de Wirth, la programmation par objets met laccent surla partie structure de donnes. Nanmoins, ceci nest passuffisant pour inclure la programmation par objets dans laprogrammation imprative, car lapproche des langages objetssapplique aussi bien au modle fonctionnel ou logique quaumodle impratif.

    Classification selon le mode de calcul

    Cette classification complte la prcdente en distinguant deux

    modles dexcution dun calcul : Les langages squentiels correspondent une excution

    squentielle de leurs instructions selon un ordre que lon peutdduire du programme. Ces langages sont aujourdhui lesplus rpandus, car ils correspondent larchitecture classiquedes ordinateurs dans lesquels on a une seule unit detraitement (modle de Von Neumann). Les langages objetssont pour la plupart squentiels.

    Les langages parallles permettent au contraire plusieursinstructions de sexcuter simultanment dans un programme.Lessor de la programmation parallle est d la disponibilit

    de machines architecture parallle. La programmation

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    11/161

    4 Les langages objets

    parallle ncessite des langages spcialiss car les langagesusuels ne fournissent pas les primitives de communication etde synchronisation indispensables. Or il savre que le modlegnral de la programmation par objets est facilementparalllisable. Une classe de langages objets, les langagesdacteurs, sont effectivement des langages parallles.

    Classification selon le typage

    Cette classification considre la notion de type qui, dans leslangages de programmation, est destine apporter une scuritau programmeur : en associant un type chaque expression

    dun programme, on peut dterminer par une analyse statique,cest--dire en observant le texte du programme sans lexcuter,si le programme est correct du point de vue du systme detypes. Cela permet dassurer que le programme ne provoquerapas derreur lexcution en essayant, par exemple, dajouterun boolen un entier.

    Dans un langage typage statique, on associe, par uneanalyse statique, un type chaque expression du programme.Cest le systme de types le plus sr, mais aussi le pluscontraignant. Pascal est lexemple typique dun langage typage statique.

    Dans un langage fortement typ, lanalyse statique permet devrifier que lexcution du programme ne provoquera pasderreur de type, sans pour autant tre capable dassocier untype chaque expression. Ceci signifie que les types devrontventuellement tre calculs lexcution pour contrlercelle-ci. Les langages qui offrent le polymorphismeparamtrique (ou gnricit), comme ADA, sont fortementtyps. La plupart des langages objets typs sont fortementtyps, et notamment Simula, Modula3 et C++.

    Dans un langage faiblement typ, on ne peut assurer, par laseule analyse statique, que lexcution dun programme neprovoquera pas derreur lie au systme de types. Il est donc

    ncessaire de calculer et de contrler les types lexcution,

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    12/161

    Introduction 5

    ce qui justifie lappellation de langage typage dynamique.Parmi les langages objets, Eiffel est faiblement typ car unepartie du contrle de types doit tre ralise lexcution.

    Dans un langage non typ, la notion de type nexiste pas, et ilne peut donc y avoir de contrle sur la validit du programmevis--vis des types. Ainsi, Lisp est un langage non typ, demme que le langage objets Smalltalk.

    La notion de type apporte une scurit de programmationindispensable dans la ralisation de gros systmes. De plus,comme nous allons le voir, elle permet de rendre lexcutiondes programmes plus efficace. Cest donc une notion

    importante, et lon peut constater que les langages objetscouvrent une grande partie de la classification ci-dessus. Cestce critre qui va nous servir structurer la suite de ce livre endistinguant dun ct les langages typs (fortement oufaiblement), dautre part les langages non typs. De nombreuxtravaux sont consacrs actuellement ltude des systmes detypes dans les langages objets car le concept dhritage, qui estlun des fondements des langages objets, ncessite dessystmes de types qui nentrent pas dans les cadres tudisjusqu prsent.

    Classification selon le mode dexcution

    Cette classification porte sur la faon dont lexcution duprogramme est ralise. Le mode dexcution nest pas proprement parler une caractristique dun langage, mais unecaractristique de limplmentation dun langage.

    Les langages interprts permettent lutilisateur dentrer desexpressions du langage et de les faire excuterimmdiatement. Cette approche offre lavantage de pouvoirtester et modifier rapidement un programme au dtriment dela vitesse dexcution. Outre la vitesse dexcution, leslangages interprts ont gnralement pour inconvnientdtre moins srs, car de nombreux contrles smantiques

    sont raliss au fur et mesure de linterprtation et non dans

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    13/161

    6 Les langages objets

    une phase prliminaire de compilation. Beaucoup de langages objets sont interprts, et tirent avantage de cette apparentefaiblesse pour donner une plus grande souplesse lexcutiondes programmes. Ainsi, une modification ponctuelle dunprogramme peut avoir des effets (contrls) sur lensemble delexcution, ce qui permet notamment de construire desenvironnements sophistiqus pour la mise au point desprogrammes.

    Les langages compils ncessitent une phase de compilationavant de passer lexcution proprement dite dunprogramme. Le but de la compilation est essentiellement deproduire du code directement excutable par la machine, donc

    plus efficace. Pour cela, le compilateur utilise en gnral lesinformations qui lui sont fournies par le systme de types dulangage. Cest ainsi que la plupart des langages typs sontcompils. De manire gnrale, les langages interprts sontplus nombreux que les langages compils car la ralisationdun compilateur est une tche complexe, surtout si lon veutengendrer du code machine efficace. Les langages objetsnchappent pas cette rgle, et il existe peu de langages objets compils.

    Les langages semi-compils ont les caractristiques deslangages interprts mais, pour une meilleure efficacit, ilsutilisent un compilateur de manire invisible pour lutilisateur.Ce compilateur traduit tout ou partie du programme dans uncode intermdiaire ou directement en langage machine. Si lecompilateur engendre un code intermdiaire, cest uninterprteur de ce code qui ralisera lexcution duprogramme. Les langages objets considrs commeinterprts sont souvent semi-compils, comme Smalltalk ou lelangage de prototypes Self.

    Classification selon la modularit

    Cette dernire classification analyse la faon dont les langagespermettent au programmeur de raliser des modules et

    dencapsuler les donnes. La modularit et lencapsulation

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    14/161

    Introduction 7

    assurent une plus grande scurit de programmation etfournissent la base de la rutilisation.

    Absence de modularit : le programmeur doit, par desconventions de programmation et de nommage, prendre encharge la modularit. Cest notamment le cas de Pascal quioblige donner des noms diffrents toutes les variables,procdures et fonctions globales, et ne permet pas de cacherdes dfinitions autrement que par les rgles de visibilit(procdures imbriques), ce qui est insuffisant. Le langage Coffre une modularit selon le dcoupage du programme enfichiers, en permettant de dclarer des variables ou fonctionsprives un fichier. En revanche, il noffre pas la possibilit

    dimbrication des procdures et fonctions.

    Modularit explicite : certains langages offrent la notion demodule comme concept du langage, que lon peut composeravec dautres notions. Par exemple, en Ada, la notion de package permet dimplmenter un module, et se combineavec la gnricit pour autoriser la dfinition de modulesgnriques (paramtrs par des types).

    Modularit implici te : les langages objets fournissent unemodularit que lon peut qualifier dimplicite dans la mesureo celle-ci ne fait pas appel des structures particulires dulangage. Au contraire, la notion de module est implicite etindissociable de celle de classe.

    La programmation par objets est une forme de program-mation modulaire dans laquelle lunit de modularit estfortement lie aux structures de donnes du langage. Parcomparaison, le langage Ada offre une modularit beaucoupplus indpendante des structures de donnes et de traitement dulangage. La modularit est souvent considre comme un atoutimportant pour la rutilisation des programmes. De ce point devue, les langages objets permettent une rutilisation bien plusimportante que la plupart des autres langages.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    15/161

    8 Les langages objets

    La programmation par objets comme un style

    De ce tour dhorizon, il faut conclure que la programmationpar objets est plus une approche gnrale de la programmationquun type facilement classable. De fait, on voit aujourdhui denombreuses extensions objets des langages existant : PascalObjet, Lisp Objet, Cobol Objet, etc. Si certaines de ces extensionsne sont pas toujours un succs, il est un fait que les principes dela programmation par objets sont applicables dans un grandnombre de contextes.

    1.2 HISTORIQUE

    La figure 1 prsente la gnalogie des principaux langages objets. On y distingue deux ples autour des langages Simula etSmalltalk.

    La famille Simula

    Le langage Simula est considr comme le prcurseur deslangages objets. Dvelopp dans les annes 60 pour traiter desproblmes de simulation de processus physiques (do sonnom), Simula a introduit la notion de classe et dobjet, la notionde mthode et de mthode virtuelle. Ces concepts restent la

    base des langages objets typs et compils, comme on le verraen dtail dans le chapitre 3. Simula a t cr dans la ligne dulangage Algol, langage typ de lpoque dont Pascal sestgalement inspir.

    Les langages de la famille Simula sont des langages impratifstyps et gnralement compils. Lintrt dun systme de typesest de permettre un plus grand nombre de contrles smantiqueslors de la compilation, et dviter ainsi des erreurs qui ne semanifesteraient qu lexcution. Typage et compilation sontdeux concepts indpendants : on peut imaginer des langagestyps interprts et des langages non typs compils. Cestnanmoins rarement le cas, car les informations dduites du

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    16/161

    Introduction 9

    Simula

    1960

    1970

    1980

    1990

    Beta Eiffel

    Objective-C ObjVlisp

    CLOS

    Flavors

    Plasma

    ACT1

    ACT2

    C++

    malltalk

    ObjectPascal

    SelfModula3

    Modula2

    Algol Lisp

    CPlannerPascal

    ABCL /1

    Figure 1 - Gnalogie des principaux langages objets

    typage permettent de gnrer du code plus efficace, ce quiencourage compiler les langages typs.

    Simula a inspir nombre de langages objets. Certains dentreeux sont maintenant largement plus connus et rpandus queSimula, comme C++ et Eiffel. Plusieurs langages ont t conusen ajoutant des concepts des langages objets un langageexistant. Ainsi, Classcal et son descendant Object Pascal ajoutentdes classes au langage Pascal, Modula3 est une rvision majeure

    de Modula2 incluant des objets, C++ est construit partir de C.Une telle approche prsente avantages et inconvnients : il estcommode de prendre un langage existant aussi bien pour lesconcepteurs que pour les utilisateurs car cela vite de toutrinventer ou de tout rapprendre. Dun autre ct, certainsaspects du langage de base peuvent se rvler nfastes pourladjonction de mcanismes des langages objets.

    La famille Smalltalk

    Dans les annes 70, sous limpulsion dAlan Kay, ontcommenc aux laboratoires Xerox PARC des recherches qui ontconduit au langage Smalltalk, considr par beaucoup comme le

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    17/161

    10 Les langages objets

    prototype des langages objets. De fait, cest Smalltalk pluttque Simula qui est lorigine de la vague des langages objetsdepuis les annes 80.

    Smalltalk sinspire de Simula pour les concepts de classes,dobjets et de mthodes, mais adopte une approche influencepar Lisp pour ce qui concerne limplmentation : Smalltalk estun langage semi-compil dans lequel tout est dcid lors delexcution. Comme dans Lisp, la souplesse due laspectinterprt de lexcution est largement exploite par le langage.

    Dun point de vue conceptuel, Smalltalk introduit la notion demtaclasse qui nest pas prsente dans Simula. Cette notion

    permet de donner une description mta-circulaire du langage detelle sorte que lon peut raliser assez simplement uninterprteur de Smalltalk en Smalltalk. Cet aspect mta-circulaire est galement prsent dans Lisp, et dans de nombreuxlangages interprts. Dans le cas de Smalltalk, les mtaclassessont accessibles lutilisateur de faon naturelle, et permettentde nombreuses facilits de programmation. Lintroduction dumodle mta-circulaire dans Smalltalk date de la premireversion du langage (Smalltalk-72). Les versions suivantes(Smalltalk-76 et Smalltalk-80) ont affin, amlior et enrichi cemodle. Dautres langages inspirs de Smalltalk sont alls plusloin dans cette direction, notamment ObjVLisp et Self.

    La meilleure preuve de la puissance de Smalltalk estlensemble des programmes raliss en Smalltalk, et lintenseactivit de recherche autour du langage, de ses concepts ou deses langages drivs. Parmi les ralisations, il faut noterlenvironnement de programmation Smalltalk, ralis XeroxPARC et implment lui-mme en Smalltalk. Cet environ-nement, qui inclut un systme dexploitation, est le premierenvironnement graphique a avoir t largement diffus.

    Smalltalk a inspir de nombreux langages de programmation.Alors que Smalltalk est un langage natif, la plupart des langagesquil a inspirs sont raliss au-dessus de Lisp. Il savre que

    Lisp fournit une base au-dessus de laquelle il est facile de

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    18/161

    Introduction 11

    construire des mcanismes dobjets. On peut nanmoinsregretter que dans nombre de cas le langage sous-jacent resteaccessible, ce qui donne lutilisateur deux modes de program-mation largement incompatibles : le mode fonctionnel de Lispet le mode de programmation par objets. Certaines incarnationsde Lisp intgrent les notions dobjets de faon presque native,comme Le_Lisp et CLOS (CommonLisp Object System).

    Autres familles, autres langages

    Si les familles Simula et Smalltalk reprsentent une grandepartie des langages objets, il existe dautres langages

    inclassables, dautres familles en cours de formation.Ainsi le langage Objective-C est un langage hybride qui

    intgre le langage C avec un langage objets de type Smalltalk.Plutt quune intgration, on peut parler dune coexistenceentre ces deux aspects, car on passe explicitement dun univers lautre par des dlimiteurs syntaxiques. Les entits dun universpeuvent tre transmises lautre, mais elles sont alors des objetsopaques que lon ne peut manipuler. Lintrt de cetteapproche est de donner lutilisateur un environnementcompil et typ (composante C) et un environnement interprtnon typ (composante Smalltalk). Parmi les logiciels raliss enObjective-C, le plus connu est certainement Interface Builder,

    lenvironnement de construction dapplications interactives dela machine NeXT.

    Une autre famille est constitue par les langages deprototypes . Ces langages, au contraire des langages objetstraditionnels, ne sont pas fonds sur les notions de classes etdobjets, mais uniquement sur la notion de prototype. Unprototype peut avoir les caractristiques dune classe, ou dunobjet, ou bien des caractristiques intermdiaires entre les deux.Dune certaine faon, ces langages poussent le concept desobjets dans ses derniers retranchements et permettent dexplorerde nouveaux paradigmes de programmation.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    19/161

    12 Les langages objets

    Une dernire famille est constitue de langages paralllesappels langages dacteurs. Dans un programme crit avec untel langage, chaque objet, appel acteur, est un processus quisexcute de faon autonome, mettant et recevant des messagesdautres acteurs. Lorsquun acteur envoie un message unautre acteur, il peut continuer son activit, sans se soucier de cequil advient du message. Le paralllisme est donc introduit parune simple modification du mode de communication entre lesobjets. Compar aux modles de paralllisme mis en uvre dansdautres langages, comme les tches de Ada, la simplicit etllgance du modle des acteurs est surprenante. Cela fait deslangages dacteurs un moyen privilgi dexploration duparalllisme.

    1.3 PLAN DU LIVRE

    Ce livre a pour but de prsenter les principes fondamentauxdes langages objets et les principales techniques deprogrammation par objets. Il ne prtend pas apprendre programmer avec tel ou tel langage objets. cet effet, lesexemples sont donns dans un pseudo-langage la syntaxeproche de Pascal. Ceci a pour but une prsentation plushomogne des diffrents concepts.

    Le prochain chapitre prsente les principes gnraux qui sont la base de la programmation par objets. Les trois chapitressuivants prsentent les grandes familles de langages objets : leslangages objets typs, cest--dire les langages de la famille deSimula (chapitre 3) ; les langages objets non typs, et enparticulier Smalltalk (chapitre 4) ; les langages de prototypes etles langages dacteurs (chapitre 5). Le dernier chapitre prsenteun certain nombre de techniques usuelles de la programmationpar objets et une bauche de mthodologie.

    Une connaissance des principes de base des langages deprogrammation en gnral et de Pascal en particulier estsuppose dans lensemble de louvrage. Les chapitres 3 et 4

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    20/161

    Introduction 13

    sont indpendants. Les lecteurs qui prfrent Lisp Pascalpeuvent lire le chapitre 4 avant le chapitre 3.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    21/161

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    22/161

    Chapitre 2

    PRINCIPES DE BASE

    Un langage objets utilise les notions de classe et dinstance,que lon peut comparer aux notions de type et de variable dunlangage tel que Pascal. La classe dcrit les caractristiquescommunes toutes ses instances, sous une forme similaire untype enregistrement ( record Pascal). Une classe dfinit doncun ensemble de champs. De plus, une classe dcrit un ensemble

    de mthodes, qui sont les oprations ralisables sur les instancesde cette classe. Ainsi une classe est une entit autonome. Au lieudappliquer des procdures ou fonctions globales desvariables, on invoque les mthodes des instances. Cetteinvocation est souvent appele envoi de message. De fait, onpeut considrer que lon envoie un message une instance pourquelle effectue une opration, cest--dire pour quelledtermine la mthode invoquer.

    On utilise souvent le terme dobjet la place dinstance. Leterme instance insiste sur lappartenance une classe : onparle dune instance dune classe donne. Le terme objet rfre de faon gnrale une entit du programme (qui peut

    tre une instance, mais aussi un champ, une classe, etc.).

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    23/161

    16 Les langages objets

    Lien d'hritage

    Lien d'instanciation

    Objet

    Classe

    Champs

    Mthodes

    Classe de Base

    Envoi de message

    Figure 2 - Illustration des notions de base

    Lhritage est la dernire notion de base des langages objets : une classe peut tre construite partir dune classeexistante, dont elle tend ou modifie la description. Cemcanisme de structuration est fondamental dans les langages objets ; il est dcrit dans la section 2.3 de ce chapitre.

    La figure 2 dcrit ces quatre notions de base, et introduit lesconventions que nous utiliserons dans les autres figures.

    2.1 CLASSES ET INSTANCESLa notion dobjet ou instance recouvre toute entit dun

    programme crit dans un langage objets qui stocke un tat etrpond un ensemble de messages. Cette notion est compareravec la notion usuelle de variable : une variable stocke un tat,mais na pas la capacit par elle-mme deffectuer destraitements. On utilise pour cela dans les langages classiques dessous-programmes, fonctions ou procdures. Ceux-ci prennentdes variables en paramtre, peuvent les modifier et peuventretourner des valeurs.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    24/161

    Principes de base 17

    Dans un langage classique, on dfinirait par exemple un typePile et des procdures pour accder une pile ou la modifier :

    Empiler, qui prend une pile et une valeur empiler ;

    Dpiler, qui prend une pile ;

    Sommet, qui prend une pile et retourne une valeur.

    Cette sparation entre variables et procdures dans leslangages classiques est la source de nombreux problmes en cequi concerne lencapsulation : pour des raisons de scurit deprogrammation, on ne souhaite pas que nimporte quelleprocdure puisse accder au contenu de nimporte quellevariable. On est alors amen introduire la notion de module.Un module exporte des types, des variables et des procdures.De lextrieur, les types sont opaques : leur implmentationnest pas accessible. On ne peut donc manipuler les variables dece type que par lintermdiaire des procdures exportes par lemodule. lintrieur du module, limplmentation des types estdcrite, et est utilisable par les corps des procdures.

    Ainsi, on peut encapsuler la notion de pile dans un module.Ce module exporte un type Pile, et les procdures Em pi le r,Dpiler et Sommet, dont limplmentation nest pas connue delextrieur. Par cette technique, un utilisateur du module nepourra pas modifier une pile autrement que par les procduresfournies par le module, ce qui assure lintgrit dune pile.

    Le module constitue donc le moyen de regrouper types etprocdures, pour construire des types abstraits. Les langagesClu, Ada et ML, parmi dautres, offrent de telles possibilits.Dans les langages qui noffrent pas de modularit (Pascal, C,Lisp etc.), le programmeur doit faire preuve dune granderigueur pour reproduire artificiellement, cest--dire sans aidedu langage, lquivalent de modules.

    Lapproche des langages objets consiste intgrer demblela notion de variable et de procdures associes dans la notiondobjet. Lencapsulation est donc fournie sans mcanisme

    additionnel. De mme quune variable appartient un type dans

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    25/161

    18 Les langages objets

    Pile

    pilesommet

    EmpilerDpilerSommet

    pilesommet O

    Figure 3 - La classe Pile et une instance

    un langage classique, dans un langage objets un objetappartient une classe. La classe est la fois un type et unmodule : elle contient une description de type, sous forme dechamps, ainsi quun ensemble de procdures associes ce type,appeles mthodes.

    Dfinir une classe

    On dfinira ainsi une classe Pile par :

    un tat reprsentant la pile (tableau, liste, etc.), constitu dechamps. Pour une reprsentation par tableau, on aura ainsideux champs : le tableau lui-mme et lindice du sommetcourant.

    la mthode Empiler, qui prend une valeur en paramtre.

    la mthodeDpiler.

    la mthode Sommet, qui retourne une valeur.

    On cre des objets partir dune classe par le mcanismed instanciation. Le rsultat de linstanciation dune classe estun objet, appel instance de la classe (voir figure 3).Linstanciation est similaire la cration dune variable dun

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    26/161

    Principes de base 19

    type enregistrement. Linstance cre stocke un tat constitudune valeur pour chacun de ses champs. Les champs sont eux-mmes des objets. Un certain nombre de classes sont prdfiniesdans les langages, telles que la classe des entiers, des caractres,etc.

    Lencapsulation, cest--dire laccs contrl aux objets, estassure naturellement par les classes. Bien que diffrant dunlangage lautre, comme nous le verrons, on peut considrerdans un premier temps que les champs sont privs alors que lesmthodes sont publ iques. Ceci signifie que les champs sontvisibles uniquement depuis le corps des mthodes de la classe,alors que les mthodes sont visibles de lextrieur. Nous allons

    maintenant dcrire le mcanisme dinvocation des mthodes.

    2.2 MTHODES ET ENVOI DE MESSAGE

    Dans les langages objets, les objets stockent des valeurs, et lesmthodes permettent de manipuler les objets. Ceci estcomparable aux langages classiques, dans lesquels les variablesstockent des valeurs et les procdures et fonctions permettent demanipuler les variables. Mais, contrairement aux procdures etfonctions qui sont des entits globales du programme, lesmthodes appartiennent aux classes des objets. Au lieudappeler une procdure ou fonction globale, on invoque unemthode dun objet. Lexcution de la mthode est alorsralise dans le contexte de cet objet.

    Linvocation dune mthode est souvent appele envoi demessage. On peut en effet considrer que lon envoie un objet,par exemple une pile, un message, par exemple empiler lavaleur 20 . Dans un langage classique, on appellerait laprocdure Empiler avec comme paramtres la pile elle-mme etla valeur 20.

    Cette distinction est fondamentale. En effet, lenvoi demessage implique que cest le receveur (ici la pile) qui dcide

    comment empiler la valeur 20, grce la mthode dtenue par

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    27/161

    20 Les langages objets

    sa classe. Au contraire, lappel de procdure des langagesclassiques implique que cest la procdure (ici Empi ler) quidcide quoi faire de ses arguments, dans ce cas la pile et lavaleur 20. En dautres termes, la programmation imprative oufonctionnelle privilgie le contrle (procdures et fonctions)alors que la programmation par objets privilgie les donnes (lesobjets), et dcentralise le contrle dans les objets.

    Le corps dune mthode est excut dans le contexte delobjet receveur du message. On a donc directement etnaturellement accs aux champs et mthodes de lobjetreceveur. Cest en fait seulement dans le corps des mthodesque lon a accs aux parties prives de lobjet, cest--dire en

    gnral ses champs (les langages diffrent sur la dfinition desparties prives).

    La dfinition conjointe des champs et des mthodes dans lesclasses est la base du mcanisme dhritage, que nous allonsmaintenant dcrire.

    2.3 LHRITAGE

    La notion dhritage est propre aux langages objets. Ellepermet la dfinition de nouvelles classes partir de classesexistantes. Supposons que lon veuille programmer le jeu desTours de Hanoi. On dispose de trois tours ; sur la premire sontempils des disques de taille dcroissante. On veut dplacer cesdisques sur lune des deux autres tours en respectant les deuxrgles suivantes :

    on ne peut dplacer quun disque la fois ;

    on ne peut poser un disque sur un disque plus petit.

    Le comportement dune tour est similaire celui dune pile :on peut empiler ou dpiler des disques. Cependant on ne peutempiler un disque que sil est de diamtre infrieur au sommetcourant de la tour.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    28/161

    Principes de base 21

    Si lon utilise un langage classique qui offre lencapsulation,on est confront lalternative suivante :

    utiliser une pile pour reprsenter chaque tour, et sassurerque chaque appel de la procdure Empiler est prcd duntest vrifiant la validit de lempilement.

    crer un nouveau module, qui exporte un type opaque Touret les procdures E m p i l e r , D p i l e r , et S o m m e t .Limplmentation de Tour est une pile ; la procdureEmpi ler ralise le contrle ncessaire avant dempiler undisque. Les procdures Dpiler et Sommet appellent leurshomologues de la pile.

    Aucune de ces deux solutions nest satisfaisante. La premirene fournit pas dabstraction correspondant la notion de tour.La seconde est la seule acceptable du point de vue delabstraction mais prsente de multiples inconvnients :

    Il faut crire des procdures inutiles : Dpiler du moduleTour ne fait quappeler Dpiler du module Pile ;

    Si lon ajoute une fonction Profondeur dans le module Pile,elle ne sera accessible pour lutilisateur de Tour que si londfinit galement une fonction Profondeur dans le moduleTour comme on la fait pour Dpiler ;

    Le problme est encore plus grave si lon dcide denleverla fonction Profondeur du module Pile : la fonctionProfondeur de Tour appelle maintenant une fonction quinexiste plus ;

    Il nest pas possible daccder directement limplmentation de la pile dans le module Tour, cause delencapsulation. On ne peut pas ajouter la fonctionProfondeur dans Tour sans dfinir une fonction quivalentedans Pile.

    Ce que lon cherche en ralit est la spcialisation dune pilepour en faire une tour, en crant un lien privilgi entre lesmodules Pile et Tour. Cest ce que permet lhritage par ladfinition dune classe Tour qui hrite de Pile.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    29/161

    22 Les langages objets

    Pile

    pilesommet

    EmpilerDpilerSommet

    Tour

    Empiler

    Figure 4 - La classe Tour hrite de la classe Pile

    Dfinir une classe par hritage

    Lorsquune classe B hrite dune classe A, les instances de Bcontiennent les mmes champs que ceux de A, et les mthodesdeA sont galement disponibles dans B. De plus, la sous-classeB peut :

    dfinir de nouveaux champs, qui sajoutent ceux de saclasse de baseA ;

    dfinir de nouvelle mthodes, qui sajoutent celles hritesdeA ;

    redfinir des mthodes de sa classe de baseA.

    Enfin, les mthodes dfinies ou redfinies dans B ont accsaux champs et mthodes de B, mais aussi ceux de A.

    Ces proprits montrent le lien privilgi qui unit B A. Enparticulier, si lon ajoute des champs et/ou des mthodes A, ilnest pas ncessaire de modifier B. Il en est de mme si lonretire des champs et/ou des mthodes de A, sauf bien sr silstaient utiliss dans les mthodes dfinies ou redfinies dans B.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    30/161

    Principes de base 23

    Dans notre exemple, on se bornera redfinir la mthodeEmpiler, pour faire le contrle de la taille des disques et appelerla mthode Empiler de Pile si lopration est valide (voir figure4). Dans ce cas, on dira que lon a spcialis la classe Pile car ona seulement redfini lune de ses mthodes. Si lon dfinissaitde nouvelles mthodes dans la classe Tour (par exempleinitialiser la tour avecNdisques de taille dcroissante), on auraitenrichi la classe Pile. Ce simple exemple montre dj quelhritage peut servir raliser deux oprations : laspcialisation et lenrichissement.

    Larbre dhritage

    Telle que nous lavons prsente, la notion dhritage induitune fort darbres de classes : une classe A reprsente par unnud dun arbre a pour sous-classes les classes reprsentes parses fils dans larbre. Les racines des arbres de la fort sont lesclasses qui nhritent pas dune autre classe.

    Si C hrite de B etB hrite de A, on dira par extension que Chrite de A. On dira indiffremment :

    B hrite deA

    B est une sous-classe deA

    B drive deA

    B est une classe drive deA

    A est une (la) superclasse deB

    A est une (la) classe de base deB

    Dans les deux dernires phrases, on emploie larticle dfinipour indiquer que A est lantcdent direct de B dans larbredhritage.

    Certains langages imposent une classe de base unique pourtoutes les autres, appele souvent Objet. Dans ce cas, la relationdhritage dfinit un arbre et non une fort. Par abus delangage, on parle dans tous les cas de larbre dhritage.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    31/161

    24 Les langages objets

    2.4 LHRITAGE MULTIPLELhritage que nous avons dfini est dit hritage simple car

    une classe a au plus une classe de base. Une gnralisation delhritage simple, lhritage multiple, consiste autoriser uneclasse hriter directement de plusieurs classes.

    Ainsi si la classe B hrite deA1, A2, An, on a les propritssuivantes :

    les champs des instances de B sont lunion des champs deA1, A2, An et des champs propres de B ;

    les mthodes dfinies pour les instances de B sont lunion

    des mthodes dfinies dans A1, A2, An et des mthodesdfinies dans B.B peut galement redfinir des mthodes deses classes de base.

    Larbre ou la fort dhritage devient alors un graphe. Pourviter des dfinitions rcursives on interdit davoir des cyclesdans le graphe dhritage. En dautres termes, on interdit uneclasse dtre sa propre sous-classe, mme indirectement.

    Cette extension, apparemment simple, cache en fait demultiples difficults, qui ont notamment trait aux problmes decollision de noms dans lensemble des champs et mthodeshrites. Certaines de ces difficults ne pourront tre

    dveloppes que dans la description plus dtaille des chapitressuivants.

    Une difficult intrinsque de lhritage multiple est la gestionde lhritage rpt dune classe donne : si B et Chritent deApar un hritage simple, et D hrite de B et de C, alors D hritedeux fois de A , par deux chemins D-B-A et D-C-A dans legraphe dhritage (figure 5). Faut-il pour autant quuneinstance de D contienne deux fois les champs dfinis dans A, oubien faut-il les partager ?

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    32/161

    Principes de base 25

    C

    c

    A

    a

    B

    b

    D

    d

    a (D.B.A)b (D.B)a (D.C.A)c (D.C)d (D)

    a (D.B.A, D.C.A)b (D.B)c (D.C)d (D)

    Figure 5 - Deux interprtations de lhritage multiple

    Selon les situations, on souhaitera lune ou lautre solution,comme le montrent les deux exemples suivants.

    Soit A la classe des engins moteur, qui contient commechamps les caractristiques du moteur. Soit B la classe desautomobiles et C la classe des grues. D est donc la classe desgrues automobiles. Les deux interprtations de lhritagemultiple sont possibles : si lon hrite deux fois de la classe desengins moteur, la grue automotrice a deux moteurs : lun poursa partie automobile, lautre pour sa partie grue. Si lon hriteune seule fois de lengin moteur, on a un seul moteur qui sert la fois dplacer le vhicule et manuvrer la grue.

    Soit maintenant A la classe des objets mobiles, contenant leschamps position et vitesse. Soit B la classe des bateaux, quicontient par exemple un champ pour le tonnage, et soit C laclasse des objets propulss par le vent, qui contient un champ

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    33/161

    26 Les langages objets

    pour la surface de la voile. D est alors la classe des bateaux voile. Une instance de D a bien entendu une seule position etune seule vitesse, et dans ce cas il faut partager les champs de Ahrits par diffrents chemins.

    Lhritage multiple noffre pas de rponse satisfaisante ceproblme. La premire interprtation correspond unecomposition de classes, la seconde une combinaison. Lemcanisme de lhritage est certainement imparfait pourcapturer la fois les notions de spcialisation, denrichissement,de composition et de combinaison. Mais lhritage nest pas leseul moyen de dfinir des classes ! Lun des piges qui guettentle programmeur utilisant un langage objets est la mauvaise

    utilisation de lhritage. La question quil faut se poser chaque dfinition de classe est la suivante : faut-il que B hritede A , ou bien B doit-elle contenir un champ qui soit uneinstance de A ?B est-il une sorte de A ou bien B contient-il unA ? Nous reviendrons au chapitre 6 sur la pratique de laprogrammation par objets, et en particulier sur ces problmes.

    2.5 LE POLYMORPHISME

    La notion de po lymo rphi sme recouvre la capacit pour unlangage de dcrire le comportement dune procdure de faonindpendante de la nature de ses paramtres. Ainsi la procdurequi change les valeurs de deux variables est polymorphe si lonpeut lcrire de faon indpendante du type de ses paramtres.De faon similaire la procdure Empiler est polymorphe si ellene dpend pas du type de la valeur empiler.

    Comme le polymorphisme est dfini par rapport la notionde type, il ne concerne que les langages typs. On distingueplusieurs types de polymorphisme, selon la technique employepour sa mise en uvre :

    Le polymorphisme ad hoc consiste crire plusieurs fois lecorps de la procdure, pour chacun des types de paramtres

    souhaits. Cest ce que lon appelle souvent la surcharge : on

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    34/161

    Principes de base 27

    peut dfinir Echanger (Entier, Entier) etEchanger (Disque,Disque) de faon indpendante, de mme que Empiler (Pile,Entier) etEmpiler (Pile, Disque). Ce type de polymorphismeest gnralement rsolu de faon statique ( la compilation). Ilutilise le systme de types pour dterminer quelle incarnationde la procdure il faut appeler, en fonction des types effectifsdes paramtres de lappel.

    Le polymorphisme dinc lus ion est fond sur une relationdordre partiel entre les types : si le type B est infrieur seloncette relation dordre au type A, alors on peut passer un objetde type B une procdure qui attend un paramtre de type A.Dans ce cas la dfinition dune seule procdure dfinit en

    ralit une famille de procdures pour tous les types infrieursaux types mentionns comme paramtres. Si Entier etDisquesont tous deux des types infrieurs Objet, on pourra dfinirles procdure Echanger (Obje t, Objet) et Empiler (Pile,Objet).

    Le polymorphisme paramtrique consiste dfinir un modlede procdure, qui sera ensuite incarn avec diffrents types. Ilest implment par la gnricit, qui consiste utiliser destypes comme paramtres. Ainsi si lon dfinit la procdureEchanger (, ), on pourra lincarner avec =Entier ou = Disque. On peut faire de mme pourEmpiler(Pile, ).

    Ces trois types de polymorphisme existent dans diverslangages classiques. En Pascal le polymorphisme existe maisnest pas accessible lutilisateur ; on ne peut donc pas lequalifier puisque sa mise en uvre est implicite. Par exemple lesoprateurs arithmtiques sont polymorphes : laddition, lasoustraction, etc. sappliquent aux entiers, aux rels, et mmeaux ensembles. De mme, les procdures dentre-sortie readetwrite sont polymorphes puisquelles sappliquent diffrentstypes de paramtres.

    Ada offre un polymorphisme ad hoc par la possibilit de

    surcharge des noms de procdures et des oprateurs. Il offre

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    35/161

    28 Les langages objets

    galement un polymorphisme paramtrique par la possibilit dedfinir des fonctions gnriques. En revanche lepolymorphisme dinclusion est limit car trs peu de types sontcomparables par une relation dordre.

    Le polymorphisme dans les langages objets

    La dfinition du polymorphisme est dpendante de la notionde type. Pourtant, tous les langages objets ne sont pas typs.Un langage objets typ est un langage objets dans lequelchaque classe dfinit un type, et dans lequel on dclareexplicitement les types des objets que lon utilise. Les langages

    objets typs fournissent naturellement le polymorphisme adhoc et le polymorphisme dinclusion. Certains langages offrentle polymorphisme paramtrique mais il ne fait pas partie desprincipes de base prsents dans ce chapitre.

    Le polymorphisme ad hoc provient de la possibilit de dfinirdans deux classes indpendantes (cest--dire nayant pas derelation dhritage) des mthodes de mme nom. Le corps deces mthodes est dfini indpendamment dans chaque classe,mais du point de vue de lutilisateur, on peut envoyer le mmemessage deux objets de classes diffrentes. Ce polymorphismead hoc est intrinsque aux langages objets : il ne ncessiteaucun mcanisme particulier, et dcoule simplement du fait que

    chaque objet est responsable du traitement des messages quilreoit.

    La dfinition de plusieurs mthodes de mme nom dans unemme classe ou dans des classes ayant une relation dhritageest une forme de polymorphisme ad hoc qui nest pas implicitedans les langages objets, bien que la plupart dentre euxoffrent cette possibilit de surcharge. De plus, la redfinitiondune mthode dans une classe drive, avec le mme nom et lesmmes paramtres que dans la classe de base, ne constitue pasune surcharge mais une redfinition de mthode, comme nouslavons vu dans la description de lhritage (section 2.5).

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    36/161

    Principes de base 29

    Les langages objets disposent galement naturellement dunpolymorphisme dinclusion que lon appelle aussipolymorphisme dhri tage. En effet, la hirarchie des classes(dans le cas de lhritage simple) induit un ordre partiel : si Bhrite de A (directement ou indirectement), alors B est infrieurA. Toute mthode de A est alors applicable un objet de classeB : cest ainsi que lon a dfini lhritage des mthodes. Lepolymorphisme dhritage nous permet donc dappliquer lamthode Sommetde la classe Pile un objet de la classe Tour,puisque Tour est une sous-classe de Pile.

    Le polymorphisme dhritage sapplique galement lhritage multiple, en dfinissant une relation dordre partiel

    compatible avec le graphe dhritage de la faon suivante : uneclasse B est infrieure une classe A si et seulement si il existeun chemin orient de B vers A dans le graphe dhritage. Legraphe tant sans cycle, on ne peut avoir la fois un cheminorient de A vers B et un chemin orient de B vers A , ce quiassure la proprit dantisymtrie.

    Le polymorphisme dhritage sapplique non seulement aureceveur des messages, mais galement au passage de paramtresdes mthodes : si une mthode prend un paramtre formel declasse A, on peut lui passer un paramtre rel de classeB siB estinfrieur A. Ainsi la mthode Empiler prend un paramtre declasse Entier. On peut lui passer un paramtre de classe Disque,siDisque hrite deEntier.

    Liaison statique et liaison dynamique

    Le polymorphisme dhritage interdit aux langages objetsun typage exclusivement statique : un objet dclar de classe Apeut en effet contenir, lexcution, un objet dune sous-classedeA. Les langages objets sont donc au mieux fortement typs,ce qui a des consquences importantes pour la compilation deces langages. Dans un langage typage statique, le compilateurpeut dterminer quelle mthode de quelle classe esteffectivement appele lors dun envoi de message : on appelle

    cette technique la liaison statique.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    37/161

    30 Les langages objets

    Lorsque le typage statique ne peut tre ralis, on doit avoirrecours la liaison dynamique, cest--dire la dtermination lexcution de la mthode appeler. La liaison dynamique faitperdre un avantage important des langages compils :lefficacit du code engendr par le compilateur. La liaisondynamique doit aussi tre utilise dans les langages non typs,car labsence de systme de types interdit toute dtermination apriori de la mthode invoque par un envoi de message. Dansles deux cas, nous verrons les techniques employes pour rendrela liaison dynamique efficace.

    Les liens troits entre polymorphisme, typage, et mode deliaison dterminent en grande partie les compromis raliss par

    les diffrents langages objets entre puissance dexpression dulangage, scurit de programmation, et performance lexcution. De ce point de vue, il nexiste pas aujourdhui delangage idal, et il est probable quil ne puisse en exister.

    2.6 LES MTACLASSES

    Nous avons dfini jusqu prsent la notion dobjet de faonassez vague : un objet doit appartenir une classe. Certainslangages permettent de considrer une classe comme un objet ;en temps quobjet, cette classe doit donc tre linstance duneclasse. On appelle la classe dune classe une mtaclasse (voirfigure 6).

    La description que nous avons donne dune classe ressembleeffectivement celle dun objet : une classe contient la liste desnoms des champs de ses instances et le dictionnaire desmthodes que lon peut invoquer sur les instances. La liste deschamps dune mtaclasse a donc deux lments : la liste desnoms de champs et le dictionnaire des mthodes.Linstanciation est une opration qui est ralise par une classe ;cest donc une mthode de la mtaclasse.

    Une mtaclasse peut galement stocker dautres champs et

    dautres mthodes. Ainsi, larbre dhritage tant une relation

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    38/161

    Principes de base 31

    Mtaclasse

    Base

    Drive

    objets

    classes

    mtaclasses

    Figure 6 - La notion de mtaclasse

    entre les classes, chaque classe contient un champ qui dsigne saclasse de base (reprsent par les flches grises paisses dans lesfigures). Une mthode de la mtaclasse permet de tester si uneclasse est sous-classe dune autre classe.

    Plusieurs modles de mtaclasses existent. Le plus simpleconsiste avoir une seule mtaclasse (appele par exempleMtaclasse). Le plus complet permet de dfinir arbitrairementdes mtaclasses. Cela autorise par exemple la redfinition delinstanciation ou lajout de mthodes de classes (dfinies dansla mtaclasse). Un modle intermdiaire, celui de Smalltalk-80,prvoit exactement une mtaclasse par classe. Lenvironnementde programmation se charge de crer automatiquement lamtaclasse pour toute classe cre par le programmeur. Cedernier peut dfinir des mthodes de classes, qui sont stockesdans le dictionnaire de la mtaclasse. Cette approche rend lesmtaclasses pratiquement transparentes pour le programmeur, et

    offre un compromis satisfaisant dans la plupart des applications.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    39/161

    32 Les langages objets

    Dans tous les cas, la notion de mtaclasse induit une rgression linfini : en effet, une mtaclasse est une classe, donc un objet,et a donc une classe ; cette classe a donc une mtaclasse, qui estun objet, etc. Cette rgression est court-circuite par une boucledans larbre dinstanciation. Par exemple, la classe Mtac lasseest sa propre mtaclasse.

    Les mtaclasses ont deux applications bien diffrentes. Lapremire est de permettre une dfinition mta-circulaire dunlangage et de rendre accessible ses propres structuresdexcution. On appelle cela la rification. Cette proprit existegalement en Lisp et permet dcrire trs simplement uninterprte Lisp en Lisp. Un langage rifi permet galement de

    construire facilement des moyens dintrospection pour aider la mise au point des programmes : trace des envois de messageet des invocations de mthodes, trace des changements de valeurdes variables, etc.

    La deuxime application des mtaclasses est de permettre laconstruction dynamique de classes. Prenons lexemple duneapplication graphique interactive dans laquelle lutilisateur peutcrer de nouveaux objets graphiques utilisables comme lesobjets primitifs (cercles, rectangles, etc.). Chaque nouvel objetgraphique, lorsquil est transform en modle, donne lieu lacration dune nouvelle classe. Cette nouvelle classe est crepar instanciation dune mtaclasse existante. En labsence demtaclasses, il faudrait dune faon ou dune autre simuler cemcanisme, ce qui peut tre fastidieux.

    Disposer de mtaclasses dans un langages objets signifie quelon peut dynamiquement ( lexcution) dfinir de nouvellesclasses et modifier des classes existantes. Cela interdit donc touttypage statique, et cest la raison pour laquelle les mtaclasses nesont disponibles que dans les langages non typs. Certainslangages typs utilisent nanmoins implicitement desmtaclasses, en autorisant par exemple la redfinition desmthodes dinstanciation. Il est galement possible de dfinirdes objets qui jouent le rle des mtaclasses pour la

    reprsentation, lexcution, de larbre dhritage. Mais la

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    40/161

    Principes de base 33

    pleine puissance des mtaclasses reste rserve aux langages nontyps.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    41/161

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    42/161

    Chapitre 3

    LANGAGES OBJETSTYPS

    Ce chapitre prsente les langages objets typs, dont Simula estlanctre. Ce dernier tant peu utilis aujourdhui, ce sont leslangages plus rcents C++, Eiffel et Modula3 qui nous servirontde base. La premire version de C++ a t dfinie en 1983 par

    Bjarne Stroustrup aux Bell Laboratories, le mme centre derecherches o sont ns Unix et le langage C. Eiffel est unlangage cr partir de 1985 par Bertrand Meyer de InteractiveSoftware Engineering, Inc. Modula3 est une nouvelle version deModula dveloppe depuis 1988 au Systems Research Center deDEC sous limpulsion de Luca Cardelli et Greg Nelson.

    Nous utilisons pour les exemples un pseudo-langage dont lasyntaxe, inspire en grande partie de Pascal, se veut intuitive.Nous donnons ci-dessous la description de ce langage sousforme de notation BNF tendue, avec les conventions suivantes :

    les mots cls du langage sont en caractres gras ;

    les autres terminaux sont en italique ;

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    43/161

    36 Les langages objets

    les crochets indiquent les parties optionnelles ; la barre verticale dnote lalternative ;

    les parenthses servent grouper des parties de rgles ;

    + indique la rptition au moins une fois ;

    * indique la rptition zro ou plusieurs fois ;

    les indicateurs de rptition peuvent tre suivis dunevirgule ou dun point-virgule qui indique le sparateur utiliser lorsquil y a plus dun lment dans la liste ;

    prog ::= ( classe | mthode )+

    classe ::= id-cls = classe [id-cls +,] {

    [champs champs+][mthodes mthodes+]

    }

    champs ::= id-champ +,: type ;

    mthodes ::= procdure id-proc (param*;);| fonction id-fonc (param*;): type ;

    type ::= id-cls | entier | boolen| tableau[ const .. const ]de type

    param ::= id-param +,: type

    mthode ::= procdure id-cls.id-proc (param*;) bloc

    | fonction id-cls.id-fonc (param*;): type bloc

    bloc ::= { [decl+] instr*;}

    decl ::= id-var +,: type ;

    instr ::= var := expr| [var.]id-proc (expr*,)| tantque expr-bool faire instr| si expr-bool alors corps [sinon instr]| pour id-var := expr expr faire instr| retourner [expr]| bloc

    var ::= id(.id-champ)* | var [ expr ]

    id ::= id-var | id-param | id-champ

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    44/161

    Langages objets typs 37

    expr ::= var | const| [var.]id-fonc (expr*,)| expr ( + | - | * |/) expr

    expr-bool ::= expr ( < | > | = | ) expr| expr-bool ( et | ou ) expr-bool| non expr-bool

    Pour complter cette description, il convient de prciser queles commentaires sont introduits par deux tirets et se poursuiventjusqu la fin de la ligne.

    3.1 CLASSES, OBJETS, MTHODES

    Dfinir une classe

    La notion de classe dobjets est une extension naturelle de lanotion de type enregistrement. En effet, une classe contient ladescription dune liste de champs, complte par la descriptiondun ensemble de mthodes.

    Notre classe Pile peut scrire :

    Pile = classe {champs

    pile : tableau [1..N] de entier;sommet : entier;

    mthodesprocdure Empiler (valeur: entier);procdure Dpiler ();fonction Sommet () : entier;

    }

    La dclaration dun objet correspond linstanciation :

    p1 : Pile;

    Linvocation des mthodes dun objet utilise loprateur

    point ( . ), qui permet traditionnellement laccs un champ

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    45/161

    38 Les langages objets

    dun enregistrement. On peut donc considrer que les mthodesse manipulent comme des champs de lobjet :

    p1.Empiler (10);p1.Empiler (15);p1.Dpiler ();s := p1.Sommet (); -- s vaut 10

    Cette notation indique clairement quel est le receveur dumessage (ici p1), la mthode invoque, et ses paramtres.Comme lenvoi de message ncessite imprativement unreceveur, on ne peut invoquer les mthodes autrement que parcette notation pointe :

    Empiler (10)

    na pas de sens car on ne connat pas le receveur du message,sauf sil y a un receveur implicite, comme nous le verrons plusloin.

    Cette mme notation pointe permet daccder aux champs delobjet :

    p1.pile [5];

    Les rgles de visibilit empchent gnralement un tel accs auxchamps. Comme nous lavons vu au chapitre 2, les champs sontdun accs priv tandis que les mthodes sont dun accs

    public. Ceci signifie que les champs dun objet sont accessiblesseulement par cet objet, alors que les mthodes sont accessiblespar tout objet grce lenvoi de message.

    Dfinir des mthodes

    La dclaration dune classe contient les en-ttes des mthodes.Nous allons dcrire leurs corps de faon spare. Pour cela,nous utiliserons la notation classe.mthode qui permet unequalification complte de la mthode. En effet, deux mthodesde mme nom peuvent tre dfinies dans deux classesdiffrentes. Rappelons que cela constitue la premire forme depolymorphisme offerte par les langages objets, le

    polymorphisme ad hoc.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    46/161

    Langages objets typs 39

    Selon les langages, la faon de dclarer les corps des mthodesvarie. La notation que nous avons choisie est inspire de C++.Eiffel adopte une autre convention qui consiste mettre lesdclarations de mthodes dans un bloc associ la classe oelles sont dfinies, ce qui pourrait tre transcrit de la faonsuivante dans notre pseudo-langage :

    Pile = classe {procdure Empiler (valeur : entier) {

    -- corps de Empiler}-- etc.

    }

    La notation qualifie que nous avons adopte ici permet desparer la dclaration de la classe de la dclaration des corps desmthodes, mais les deux mcanismes sont strictementquivalents.

    Dans notre exemple, si lon omet les tests de validit desoprations (pile vide, pile pleine), on a les dfinitions de corpsde mthodes suivantes :

    procdure Pile.Empiler (valeur: entier) {-- attention : pas de test de dbordementsommet := sommet + 1;pile [sommet] := valeur;

    }procdure Pile.Dpiler () {

    -- attention : pas de test de pile videsommet := sommet - 1;

    }

    fonction Pile.Sommet () : entier {retourner pile [sommet];

    }

    Une mthode est toujours invoque avec un objet receveur,qui sert de contexte son excution. Laccs aux champs delobjet receveur (pile et sommet dans notre exemple) se fait en

    mentionnant directement leurs noms.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    47/161

    40 Les langages objets

    Pour tre plus prcis, les entits accessibles depuis unemthode sont :

    lobjet receveur,

    les champs de lobjet receveur,

    les mthodes de lobjet receveur,

    les paramtres de la mthode,

    les variables locales de la mthode,

    les objets dclars de faon globale au programme.

    Les champs des objets et les paramtres tant eux-mmes desobjets, on peut invoquer leurs mthodes. Pour illustrer cela,supposons lexistence dune classe Fichier et crivons denouvelles mthodes pour la classe Pile (ces mthodes doiventtre ajoutes la dclaration de la classe Pile) :

    procdure Pile.crire (sortie : Fichier) {pour i := 1 sommet faire sortie.crire (pile [i]);

    }procdure Pile.Vider () {

    tantque sommet > 0 faire Dpiler ();}

    Pile.crire invoque la mthode crire du paramtre sortie.Elle crit sur ce fichier lensemble des lments de la pile. Nous

    supposons ici que cri re est une mthode de la classeFichier.Pile.Vider invoque la mthode Dpiler sans la qualifierpar un receveur, ce qui semble contraire ce que nous avons ditplus haut. Mais ici on est dans le contexte dun objet receveurde classe Pile, qui devient le receveur implicite de Dpiler (voirfigure 7). Cest par un mcanisme identique que sommet reprsente le champ sommetde lobjet receveur du message.

    La pseudo-variable moi

    Bien que lobjet receveur soit implicite en ce qui concernelaccs aux champs et aux mthodes, il est parfois ncessaire dele rfrencer explicitement, par exemple pour le passer enparamtre une autre mthode. Selon les langages, il porte le

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    48/161

    Langages objets typs 41

    Pile

    Vider ( ) {tant que sommet > 0 faire

    Dpiler ( );}

    Dpiler ( ) {

    }

    Vider1

    2

    3

    pilesommet

    4

    Figure 7 - Accs aux champs et aux mthodes.Les flches hachures reprsentent linvocation de mthode

    nom rserv de self (Modula3, mais aussi Smalltalk), Current (Eiffel), this (C++). Nous lappellerons moi .Moi nest pas proprement parler un objet, mais une faon derfrencer le receveur de la mthode en cours dexcution. Onutilise pour cela le terme de pseudo-variable.

    Lexemple suivant illustre lutilisation de moi. Les classesSommetetArc permettent de reprsenter un graphe. Un sommetest reli un ensemble darcs, et un arc relie deux sommets.

    Sommet = classe {champs

    -- reprsentation des arcs adjacentsmthodes

    procdure Ajouter (a : Arc);}

    Arc = classe {champs

    dpart, arrive : Sommet;mthodes

    procdure Relier (s1, s2 : Sommet);}

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    49/161

    42 Les langages objets

    crivons le corps de la mthode Relier de la classeArc :procdure Arc.Relier (s1, s2 : Sommet) {

    dpart := s1;arrive := s2;s1.Ajouter (moi);s2.Ajouter (moi);

    }

    Cet exemple montre quil est indispensable de pouvoirrfrencer explicitement le receveur du message dans le corpsde la mthode invoque : cest larc qui reoit le message Relierqui doit tre ajout aux sommets s1 et s2.

    On peut galement utiliser la pseudo-variable moi pourqualifier les champs et les mthodes locales, mais cela napporterien sinon une notation plus lourde. La mthode Vider de laclasse Pile pourrait ainsi scrire comme suit :

    procdure Pile.Vider () {tantque moi.sommet > 0 faire moi.Dpiler ();

    }

    Les classes primitives

    Nous avons utilis pour dfinir la classe Pile un champ detype entier et un champ de type tableau, considrant ces typescomme prdfinis dans le langage. Le statut de ces typesprdfinis varie dun langage lautre. En gnral, les typesatomiques (entier, boolen, caractre) ne sont pas des classes eton ne peut en hriter. Les types structurs comme les tableauxsont parfois accessibles comme des classes gnriques.

    On peut toujours construire une classe qui contient un champdun type prdfini. Malheureusement, moins de disposer demcanismes de conversion implicite entre types atomiques etclasses, on ne peut utiliser ces classes de faon transparente.

    Par exemple, si lon dfinit la classe En ti er , contenant unchamp de type entier, comme suit :

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    50/161

    Langages objets typs 43

    Entier = classe {champs

    valeur : entier;mthodes

    procdure Valeur (v : entier);}procdure Entier.Valeur (v : entier) {

    valeur := v;}

    et si lon change le type entier par la classeEntier dans la classePile, on ne peut plus crire

    p1.Empiler (10);

    car 10 est une valeur du type prdfini entier, et non un objet dela classe Entier . Sans mcanisme particulier du langage, il fautcrire :

    v : Entier;v.Valeur (10);p1.Empiler (v);

    La diffrence de statut entre types atomiques et classes rsultedun compromis dans lefficacit de limplmentation deslangages objets typs. Cette diffrence ne pose que peu deproblmes dans la pratique, bien quelle soit peu satisfaisantepour lesprit.

    3.2 HRITAGE

    Nous allons maintenant prsenter comment est mis en uvrelun des concepts de base des langages objets : lhritage.Nous allons pour cela prsenter les deux principales utilisationsde lhritage, la spcialisation et lenrichissement.

    Spcialisation par hritage

    Nous dfinissons maintenant une sous-classe de la classe Pile,la classe Tour . Rappelons quune tour est une pile dont lesvaleurs sont dcroissantes.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    51/161

    44 Les langages objets

    Tour = classe Pile {mthodes

    procdure Initialiser (n : entier);fonction PeutEmpiler (valeur : entier) : boolen;procdure Empiler (valeur : entier);

    }

    Lhritage est mentionn dans len-tte de la dclaration(comparer avec la dclaration de la classe Pile). La procdureInitialiser empile n disques de tailles dcroissantes :

    procdure Tour.Initialiser (n : entier) {sommet := 0;

    pour i := n 1 faire Empiler (i);}

    Init ialiser invoque la mthode Empiler, qui est redfinie dansla classe Tour. Dfinissons maintenant les corps des mthodesPeutEmpiler etEmpiler :

    fonction Tour.PeutEmpiler (valeur : entier) : boolen {si sommet = 0

    alors retourner vrai;sinon retourner valeur < Sommet ();

    }

    La mthode PeutEmpiler rfrence le champ sommet de saclasse de base ainsi que la mthode Sommet dfinie galement

    dans la classe de base. Elle teste si la valeur peut tre empile,cest--dire si la tour est vide ou sinon si la valeur est plus petiteque le sommet courant de la tour. Empiler utilise PeutEmpilerpour dcider de lempilement effectif de la valeur :

    procdure Tour.Empiler (valeur : entier) {si PeutEmpiler (valeur)

    alors Pile.Empiler (valeur);sinon erreur.crire (impossible dempiler);

    }

    On suppose ici lexistence dun objet global erreur, de laclasse Fichier, qui permet de communiquer des messages lutilisateur grce sa mthode crire .

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    52/161

    Langages objets typs 45

    Tour

    Empiler (valeur: entier) {

    Pile. Empiler (valeur);

    }

    Pile

    Empiler

    Figure 8 - Spcialisation de la mthode Empiler

    Lappel de Pile.Empiler (valeur) mrite quelques explications.La classe Tour est une spcialisation de la classe Pile, cest--dire que lon a simplement redfini une mthode de la classePile. Dans cette situation, la mthode redfinie a souvent besoinde rfrencer la mthode de mme nom dans la classe de base.Si lon avait crit

    Empiler (valeur)

    on aurait provoqu un appel rcursif, puisque lon est dans lecorps de la mthodeEmpiler de la classe Tour. La notation

    Pile.Empiler (valeur)

    permet de qualifier le nom de la mthode appele. Comme Tourhrite de Pile, la mthode Empiler de Pile est accessible dans lecontexte courant, mais elle est cache par sa redfinition dans laclasse Tour (voir figure 8). La notation qualifie permet laccs la mthode de la classe de base, dans le contexte de lobjetreceveur. Elle ne peut tre utilise que dans cette situation.

    Une fois la classe Tour dfinie, on peut en dclarer desinstances et invoquer des mthodes :

    t : Tour;...t.Empiler (10);

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    53/161

    46 Les langages objets

    t.Dpiler;t.Empiler (20);t.Empiler (5); -- impossible dempiler

    Comme on la dit, les mthodes de la classe de base restentaccessibles. Dans cet exemple, t.Dpiler invoque Pile.Dpiler.

    Enrichissement par hritage

    Nous allons maintenant dfinir une classe drive de la classeTour en ajoutant la possibilit de reprsenter graphiquement latour. Pour cela nous supposons lexistence des classes Fentre etRectangle, avec les dfinitions partielles suivantes :

    Fentre = classe {mthodes

    procdure Effacer ();}

    Rectangle = classe {mthodes

    procdure Centre (posX, posY : entier);procdure Taille (largeur, hauteur : entier);procdure Dessiner (f : Fentre);

    }

    TourG est une sous-classe de Tour dfinie comme suit :

    TourG = classe Tour {champs

    f : Fentre;x, y : entier;

    mthodesprocdure Placer (posX, posY : entier);procdure Dessiner ();procdure Empiler (valeur: entier);procdure Dpiler ();

    }

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    54/161

    Langages objets typs 47

    Il sagit ici dun enrichissement : trois nouveaux champsindiquent la fentre de lcran dans laquelle sera affiche latour, et la position de la tour dans cette fentre. Chaque tage dela tour sera reprsent par un rectangle de taille proportionnelle la valeur entire qui le reprsente dans la tour. Deux nouvellesmthodes permettent daffecter une position la tour et dedessiner la tour. Enfin, les mthodes Empiler et Dpiler sontredfinies afin dassurer que la tour est redessine chaquemodification. Le corps des mthodes est dcrit ci-dessous.

    Placer affecte la position de la tour et la redessine.

    procdure TourG.Placer (posX, posY : entier) {

    x := posX;y := posY;Dessiner ();

    }

    Dessiner commence par effacer la fentre, puis redessine latour tage par tage. Dessiner est similaire dans son principe lamthode crire dfinie auparavant dans la classe Pile.

    procdure TourG.Dessiner () {rect : Rectangle;f.Effacer ();pour i := 1 sommet faire {

    rect.Centre (x, y - i);

    rect.Taille (pile [i], 1);rect.Dessiner (f);

    }}

    Empiler etDpiler invoquent la mthode de mme nom dansla classe de base Tour et redessinent la tour. On pourrait bien sroptimiser laffichage, mais ce nest pas lobjet de lexemple.

    procdure TourG.Empiler (valeur: entier) {Tour.Empiler (valeur);Dessiner ();

    }

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    55/161

    48 Les langages objets

    procdure TourG.Dpiler () {Tour.Dpiler ();Dessiner ();

    }

    Il est noter que Tour.Dpiler na pas t dfinie. En fait laclasse Tour hriteDpiler de la classe Pile, donc Tour.Dpiler estidentique Pile.Dpiler . Nanmoins, il serait imprudentdutiliser Pile.Dpiler directement car on peut tre amen redfinir Dpiler dans Tour.

    3.3 HRITAGE MULTIPLE

    Lhritage multiple permet dutiliser plusieurs classes de base.La classe TourG , par exemple, reprsente une tour qui saitsafficher dans une fentre. En changeant lgrement de pointde vue, on peut considrer que la classe TourG est la fois unetour et une fentre. On a alors un hritage multiple de Tour etde Fentre (figure 9). Voyons la dfinition de la classe TourGMainsi obtenue :

    TourGM = classe Tour, Fentre {champs

    x, y : entier;mthodes

    procdure Placer (posX, posY : entier);procdure Dessiner ();procdure Empiler (valeur: entier);procdure Dpiler ();

    }

    Lhritage multiple est mentionn en faisant apparatre la listedes classes de base dans len-tte de la dclaration. Le champ fnapparat plus : il est remplac par lhritage de Fentre.

    La seule mthode qui change par rapport la classe TourG estla mthodeDessiner :

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    56/161

    Langages objets typs 49

    Pile

    Tour Fentre

    Tour GM

    Figure 9 - Hritage multiple de la classe TourGM

    procdure TourGM.Dessiner () {rect : Rectangle;Effacer ();pour i := 1 sommet faire {

    rect.Centre (x, y - i);rect.Taille (pile [i], 1);rect.Dessiner (moi);

    }}

    On constate que linvocation de la mthode Effacer nest plusqualifie par le champ f. En effet, cette mthode est maintenanthrite de la classe Fentre . Par ailleurs, linvocation de lamthode Dessiner prend comme argument la pseudo-variablemoi . En effet, TourGM hrite maintenant de Fentre, donc uneTourGMest une fentre : on utilise ici le polymorphismedhritage sur le paramtre de la mthode Dessiner.

    Bien que les diffrences entre les implmentations de TourG etTourGM soient minimes, leffet de lhritage multiple est plus

    important quil ny parat. En effet, alors que TourG nhrite

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    57/161

    50 Les langages objets

    que des mthodes de Tour, TourGMhrite de celles de Tour etde Fentre. Il est donc tout fait possible dcrire :

    tgm : TourGM;tgm.Placer (100, 100);tgm.Empiler (20);tgm.Empiler (10);tgm.Effacer ();

    Linvocation dEffacer est correcte puisque Effacer est hritede Fentre. Pour un objet de la classe TourG, cet envoi demessage aurait t illicite. On voit donc que le choix

    dimplmenter une tour graphique par la classe TourG ou laclasse T o u r G M dpend du contexte dutilisation danslapplication. Lhritage, comme lhritage multiple, ne doit pastre utilis comme une facilit dimplmentation, mais commeune faon de spcifier des liens privilgis entre classes.

    Lhritage multiple cre cependant une ambigut : supposonsque la classe Fentre dfinisse une mthode crire, qui imprimeson tat. La classe Tour de son ct hrite une mthode crirede la classe Pile. Que se passe-t-il si lon crit :

    tgm.crire (fich);

    Il y a un conflit car la classe TourGMhrite deux fois de la

    mthode crire . Les langages rsolvent ce problme dediffrentes manires :

    lordre de lhritage multiple dtermine une priorit entreles classes ; dans notre cas TourGMhrite dabord de Tour,puis de Fentre, donc Tour.crire masque Fentre.crire .Le rsultat est donc dimprimer la tour, cest--dire la pile.

    il faut qualifier linvocation de la mthode, par exempletgm.Fentre.crire (fich). Cela suppose donc quelutilisateur connaisse le graphe dhritage, ce qui nefavorise pas lide dencapsulation et dabstraction. Cest lemcanisme choisi par Modula3 et C++.

    il faut renommer, lors de lhritage, les mthodes quiengendrent des conflits. On peut ainsi hriter de Tour, et de

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    58/161

    Langages objets typs 51

    Fentre en renommant la mthode crire hrite de fentreencrireF. tgm.crire(fich) imprime donc la tour, alors quetgm.crireF(fich) imprime la fentre. Cest le mcanismeimpos par Eiffel, et disponible en C++.

    il faut dfinir une mthode crire dans la classe TourGM,qui lvera le conflit en masquant les deux mthodes crire.

    La dernire mthode est toujours ralisable. Dans notreexemple, on pourrait dfinir cette mthode de la faon suivante :

    procdure TourGM.crire (sortie : Fichier) {Tour.crire (sortie);Fentre.crire (sortie);sortie.crire (x);sortie.crire (y);

    }

    Cette mthode crit la partie Tour , la partie Fentre et leschamps propres de To u r G M . Les invocations qualifiesTour.crire et Fentre.crire lvent lambigut en mme tempsquelles vitent lappel rcursif de TourGM.crire.

    Lorsque des champs de plusieurs classes de base portent lemme nom, les mmes problmes de conflits daccs se posent.Ils sont rsolus par un accs qualifi (en C++) ou parrenommage (en Eiffel).

    Nous avons voqu au chapitre prcdent dautres problmesconcernant lhritage multiple, et notamment lhritage rpt :que se passe-t-il si une classe hrite, directement ouindirectement, plusieurs fois de la mme classe ? Faut-ildupliquer les champs de cette classe ou doivent-ils apparatreune seule fois ?

    En C++, la notion de classe de base virtuelle permet de ne voirquune fois une classe de base qui est accessible par plusieurschemins dhritage. En Eiffel, le contrle est plus fin car chaquechamp dune classe de base hrite plusieurs fois peut tredupliqu ou partag, selon que le champ est renomm ou non.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    59/161

    52 Les langages objets

    3.4 LIAISON DYNAMIQUETel que nous lavons prsent, lhritage des mthodes dans

    un langage objets typ permet de dterminer de faon statiqueles invocations de mthodes : pour un objet o de la classe A ,lappel

    o.m (paramtres)

    est rsolu en recherchant dans la classe A une mthode de nomm . Si elle nest pas trouve, la recherche se poursuit dans laclasse de base de A, et ainsi de suite jusqu trouver la mthodeou atteindre la racine de larbre dhritage. Si la mthode esttrouve, linvocation de mthode est correcte, sinon elle est

    errone.

    Le compilateur peut profiter de cette recherche, destine vrifier la validit du programme, pour engendrer le code quiappelle directement la mthode trouve. Cela vite unerecherche similaire lexcution et rend donc le programmeplus efficace. Cela sappelle la liaison statique.

    Malheureusement, le polymorphisme dhritage rend cetteoptimisation invalide, comme le montre lexemple suivant :

    t : Tour ;tg : TourG ;

    ...t := tg ;t.Empiler (10) ; -- que se passe-t-il ?

    Laffectation de la tour graphique tg la tour simple t estcorrecte en vertu du polymorphisme dhritage : une tourgraphique est un cas particulier de tour, donc un objet de typetour peut rfrencer une tour graphique. En utilisant la liaisonstatique, le compilateur rsout linvocation dEmpiler parlappel de Tour.Empiler, car t est dclar de type Tour. Mais tcontient en ralit, lors de lexcution, un objet de classe TourG,et linvocation de Tour.Empiler est invalide : il aurait falluinvoquer TourG.Empiler.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    60/161

    Langages objets typs 53

    Dans cet exemple, le typage statique ne nous permet pas desavoir que t contient en ralit un objet dune sous-classe deTour et la liaison statique brise la smantique du polymorphismedhritage.

    Les mthodes virtuelles

    Ce problme avait t not ds Simula, et rsolu enintroduisant la notion de mthode virtuelle : en dclarantEmpiler virtuelle, on indique dutiliser une liaison dynamique etnon plus une liaison statique : le contrle de type a toujours lieu la compilation, mais la dtermination de la mthode appeler

    a lieu lexcution, en fonction du type effectif de lobjet. Oncomprend aisment que la liaison dynamique est plus chre lexcution que la liaison statique, mais quelle est indispensablesi lon veut garder la smantique du polymorphisme dhritage.

    Lexemple suivant montre une autre situation dans laquelle lesmthodes virtuelles sont indispensables :

    tg : TourG ;tg.Initialiser (4);

    On initialise une tour graphique avec quatre disques. Nousallons voir que l encore, il faut que Empi ler ait t dclarevirtuelle. La procdure In it ialiser est hrite de Tour. Voicicomment nous lavons dfinie :

    procdure Tour.Initialiser (n : entier) {pour i := n 1 faire Empiler (i);

    }

    Si Empi le r nest pas dclare virtuelle, son invocation estrsolue par liaison statique par lappel de Tour.Empiler, puisquele receveur est considr de classe Tour. Lorsque lon invoquetg.Initialiser(4), le receveur sera en ralit de classe TourG, etcest la mauvaise version dEmpi ler qui sera invoque (voirfigure 10). En dclarant Empiler virtuelle, ce problme disparat.En loccurrence, cest TourG.Empiler qui sera invoque,provoquant le dessin de la tour au fur et mesure de son

    initialisation.

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    61/161

    54 Les langages objets

    Initialiser (4)

    TourG

    Empiler (v) {}

    Tour

    Empiler (v) {}

    Initialiser (n) {pour i := n 1

    Empiler (i)}

    Statique

    Dynamique

    13

    3'

    2

    tg

    Figure 10 - Liaison statique contre liaison dynamique

    Lutilisation extensive du polymorphisme dans les langages objets pourrait laisser penser que toutes les mthodes doiventtre virtuelles. Cest la solution choisie dans Eiffel et Modula3,qui assurent au programmeur que tout se passe comme si laliaison tait toujours dynamique.

    Par contre, C++ et Simula obligent dclarer explicitement lesmthodes virtuelles comme telles. Cela offre au programmeur lapossibilit de choisir entre la scurit de la liaison dynamique etlefficacit de la liaison statique, ses risques et prils. Enpratique, on se rend compte quun nombre limit de mthodesont effectivement besoin dtre virtuelles, mais quil est difficilede dterminer lesquelles, surtout lorsque les classes sontdestines tre rutilises.

    Limplmentation de la liaison dynamique

    Limplmentation usuelle de la liaison dynamique consiste attribuer chaque mthode virtuelle un indice unique pour la

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    62/161

    Langages objets typs 55

    une Tour

    une Pile

    une autre Pile

    Pile

    EmpilerDpiler

    Tour

    EmpilerDepiler

    Code de Pile.EmpilerCode de Pile.Dpiler

    Code de Tour.Empiler

    Figure 11 - Implmentation de la liaison dynamique

    hirarchie de classes laquelle elle appartient. Lors delexcution, chaque classe est reprsente par une table, quicontient pour un indice donn ladresse de la mthodecorrespondante de cette classe. Chaque objet dune classecontenant des mthodes virtuelles contient ladresse de cette

    table (figure 11). Linvocation dune mthode exigesimplement une indirection dans cette table. Le cot delimplmentation est donc le suivant :

    une table, dite table virtuelle, par classe ;

    un pointeur vers la table virtuelle par objet ;

    une indirection par invocation de mthode virtuelle.

    On peut considrer ce cot comme acceptable, surtout si on lecompare au cot dinvocation des mthodes dans les langagesnon typs (dcrit la fin de la section 4.3 du chapitre 4). Onpeut aussi considrer quil est inutile de supporter ce cotsystmatiquement, et cest la raison pour laquelle Simula et C++

    donnent le choix (et la responsabilit) au programmeur de

  • 7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)

    63/161

    56 Les langages objets

    dclarer virtuelles les mthodes quil juge utile. Modula3, aucontraire, tire parti de la table virtuelle ncessaire chaque objetpour autoriser un objet redfinir des mthodes : il suffit de luicrer une table virtuelle propre. On quitte alors le modle strictdes langages de classes, puisque ce nest plus la classe quidtient le comportement de toutes ses instances.

    3.5 RGLES DE VISIBILIT

    La dclaration explicite des types dans un langage assu