Programmation à Objets avec Smalltalk

Programmation à Objets avec Smalltalk-80

Le modèle à objets de Smalltalk-80

Concepts et principes de base

Smalltalk est un langage à objets pur. Cela signi e qu’il y a seulement deux concepts de base : l’objet et l’envoi de message. Tout le reste du langage est dÈrivÈ de ces deux concepts.

Objet et classe

Smalltalk est un langage purement à objets à objets.
Principe 2.1 (objet) Toute entitÈ en Smalltalk est un objet. Tout objet a une identitÈ propre et implicite.
Chaque objet a un numÈro (une identitÈ) distinct dans le systÉme. Ce qui di Èrencie deux objets, c’est leur identitÈ. Un objet sert à stocker et accÈder à des informations propres et à envoyer ou rÈpondre à des messages. Un objet a un Ètat et un comportement . L’Ètat est l’ensemble des valeurs que dÈtient l’objet. Le comportement est l’ensemble des opÈrations (procÈdures ou fonctions), appelÈes mÈthodes que l’objet peut rÈaliser. Par exemple, prenons un point p1 = (5,6) dÈ ni par ses coordonnÈes cartÈsiennes. L’Ètat est dÈcrit par les deux coordonnÈes 5 et 6 dans le plan. Le comportement est dÈplacer, distance, etc. On dit qu’un objet encapsule des donnÈes (l’Ètat) et des traitements sur ces donnÈes (le comportement) au sein d’une mÍme entitÈ.
Principe 2.2 (classe) Tout objet est instance d’une classe.
La classe regroupe les objets ayant mÍme structure (mÍme forme d’Ètat) et mÍme com-portement. Par exemple, notre point p1 est dÈ ni dans une classe Point. La structure est dÈ nie par un ensemble de variables d’instances. Par exemple, la structure du point p1 = (5,6) est formÈe de deux variables x et y. Le comportement est dÈcrit par un ensemble de mÈthodes. Une mÈthode est une abstraction procÈdurale (procÈdure, fonction) dÈ nie par un pro l et un corps. Le pro l comprend un nom de mÈthode, appelÈ sÈlecteur de la mÈthode et des noms de variables en paramètres. Syntaxiquement, une mÈthode se présente comme suit :
sÈlecteur et nom des arguments
« commentaires dÈcrivant la mÈthode »
| noms de variables temporaires |
instructions
Chaque objet dÈtient les valeurs de ses variables d’instances mais son comportement est situÈ au niveau de sa classe. L’objet est reliÈ à sa classe par la relation d’instanciation
Le point p1 a pour coordonnÈes x = 5 et y = 6. Ses mÈthodes sont regroupÈes dans la classe Point avec qui il est reliÈ par une relation d’instanciation. L’Ètat d’un objet est alors dÈ ni par la valeur de ses variables d’instance. C’est ce qui permet de comparer deux objets d’une mÍme classe. En fait, chaque objet est unique dans le systÉme : l’objet possÉde une identitÈ.
La classe reprÈsente à la fois l’ensemble de ses instances et un modÉle des instances. Dans le comportement on distingue les mÈthodes applicables aux objets, ce sont les mÈthodes d’instance, des mÈthodes applicables à la classe elle-mÍme, appelÈes mÈthodes de classe. Les mÈthodes de classe servent notamment à crÈer les objets de la classe. On dit qu’un objet est instanciÈ par la classe. Les termes instance et objet sont synonymes. Une classe qui n’a pas de mÈthode d’instanciation est dite classe abstraite. De mÍme, une mÈthode dont la sÈmantique n’est pas dÈ nie est dite mÈthode abstraite .

Envoi de message

Principe 3.1 (envoi de message) Un objet n’est accessible que par envoi de message.
L’envoi de message est un appel de mÈthode d’un objet. L’objet destinataire de l’envoi de message est appelÈ receveur. On parle de sÈlection simple car il n’y a qu’un seul rece-veur. Syntaxiquement, l’envoi de message s’Ècrit di Èremment selon le nombre de paramÉtres. Chaque paramÉtre est introduit par un mot-clÈ su xÈ par ‘ :’.
mÈthode unaire : receveur sÈlecteur
mÈthode binaire : receveur sÈlecteur: argument
mÈthode n-aire : receveur sÈlecteur1: argument1 … sÈlecteurn: argumentn
Le sÈlecteur est l’union des mots-clÈs sÈlecteur = sÈlecteur1:… sÈlecteurn.
Exemple :
corner: aPoint
« Rend un rectangle dont l ‘ origine est le receveur et l ‘ extrÈmitÈ est le point donnÈ en paramÉtre . C’est une forme in xÈe de crÈation de rectangles . »
« Rectangle origin: self corner: aPoint
La seule structure de contrÙle est l’envoi de message. Deux envois de message sont sÈparÈs par un ‘.’. Deux envois de messages consÈcutifs au mÍme receveur sont sÈparÈs par un ‘ ;'(cascade). Les structures de contrÙle habituelles ( alternatives,itÈrations) sont donc implantÈes par des envois de message. Plus prÈcisÈment ce sont des mÈthodes de la classe Boolean pour les alternatives et de la classe Collection pour les itÈrations.

Eléments du langage

Variables

En Smalltalk, les variables sont dÈclarÈes par un nom. Leur type n’est connu qu’à l’exÈ-cution. On distingue plusieurs sortes de variables :
les variables liÈes à une expression en cours d’Èvaluation : variables locales,
les variables liÈes à une mÈthode : variables locales,
les variables propres à une instance : variables d’instance,
les variables partagÈes par les instances d’une classe : variables de classes ,
les variables partagÈes par un ensemble d’instance, appelÈes aussi variables de pool. Par rapport à d’autres langages, Smalltalk possÉde deux types de variables d’instances :
les variables rÈfÈrant à un objet (classique) et les variables indexÈes, contenant un tableau de variable. Les variables indexÈes sont gÈrÈes directement par les primitives du langage. Nous n’en dirons pas plus. Sachez cependant que les variables indexÈes facilitent le codage et l’e cacitÈ d’accÉs pour certains objets tels que les collections ou les vues.
Chaque variable est accessible dans la portÈe sous-entendue par son nom : une variable locale est visible dans le bloc qui la dÈclare, une variable d’instance est visible par une ins-tance, une variable de classe est visible par la classe, ses sous-classes et ses instances. Ces di Èrents types de variables seront examinÈs dans le sections suivantes. Attention, il ne faut pas confondre les variables d’instance de la mÈta-classe des variables de classe. Les premiÉres sont propres à chaque mÈtaclasse : si elles sont modi Èes elles le sont uniquement pour la classe. Les secondes sont communes à la classe et ses sous-classes : si une mÈthode modi e la valeur alors toutes les classes ont cette nouvelle valeur.

Réflexion : la variable self

Il est possible pour le receveur d’un message de s’envoyer un message. La construction syntaxique pour cela est la pseudo variable self, qui dÈsigne le receveur. Nous dÈ nissons ainsi des mÈthodes rÈcursives, comme la fonction factorielle. La fonction factorielle est dÈ nie dans la classe des entiers. Le corps de la mÈthode est une alternative sur la valeur de l’entier. Si l’entier est nul alors la factorielle est Ègale à 1 sinon elle est Ègale au produit de l’entier par la factorielle de son prÈcÈdent.
factorielle
« rend la valeur factorielle du receveur  »
self = 0
ifTrue : [ « 1]
ifFalse : [  » self ( self 1) factorielle ]
En Smalltalk, une expression alternative est est codÈe par un envoi de message à un ob-jet expr bool de type boolÈen (de classe Boolean) : expr bool ifTrue:[bloc1] ifFalse: [bloc2]. Cet envoi de message a deux paramÉtres de type bloc. Un bloc est une suite d’ins-truction ÈvaluÈe uniquement à l’exÈcution. La notion de bloc est dÈtaillÈe dans la section 4.2. L’envoi de message est ÈvaluÈ comme suit : si le boolÈen est vrai le bloc bloc1 est exÈcutÈ sinon le bloc bloc2 est exÈcutÈ. Notez que le retour du rÈsultat d’une opÈration se fait en prÈ xant par . Il s’agit d’une sortie inconditionnelle de la mÈthode en cours.

Objets littéraux

En programmation, on distingue les types de base des autres types (types structurÈs, types abstraits, classes). Les types de base sont issus de la reprÈsentation interne de la machine (exemples : boolÈens, entiers, rÈels). En Smalltalk, tout est uni È dans le concept d’objet : les types de base sont encapsulÈs dans des classes. En fait, lorsqu’on regarde les mÈthodes des objets des classes de ces objets, nous nous apercevons qu’elles font appel à des fonctions primitives inaccessibles. Il y a donc en Smalltalk des types de base (des types dont les valeurs ne sont pas des objets). Par exemple, la plupart des classes feuilles de la hiÈrarchie d’hÈritage suivante sont des classes primitives.
Object ()
Magnitude ()
ArithmeticValue ()
Number ()
Fraction (‘numerator’ ‘denominator’)
Integer ()
LargeNegativeInteger ()
LargePositiveInteger ()
SmallInteger ()
LimitedPrecisionReal ()
Double ()
Float ()
Point (‘x’ ‘y’)
Character ()
Date (‘day’ ‘year’)
LookupKey (‘key’)
Association (‘value’)
Time (‘hours’ ‘minutes’ ‘seconds’)
Des objets littÈraux sont des objets connus et dÈsignÈs par leur valeur (unique) : nil dÈsigne un objet vide, 55 pour un entier, #toto pour un symbole, ‘toto’ pour une chaÓne de caractÉres, etc.

Affectation, Egalité, copie

L’affectation d’un objet à une variable se fait par variable := objet, o˘ objet est un objet rÈsultat d’une expression. En fait, la variable reÁoit une valeur qui est l’identitÈ de l’objet rÈsultat. Cette identitÈ est l’adresse de l’objet dans le systÉme (adressage unique et global). L’accÉs à l’objet se fait donc indirectement par son adresse. Cette indirection a un e et sur la copie et la comparaison d’objets. Ces protocoles sont dÈ nis dans la classe Object.
La copie d’objet est soit uniquement sur la valeur des variables d’instances (copie de la structure et valuation des variables d’instance par les identitÈs) soit une copie complÉte et en profondeur des valeurs de l’objet (rÈcursif). La premiÉre est appelÈe shallow copy et la seconde est appelÈe deep copy.
De mÍme l’ÈgalitÈ entre deux variables dÈsignant des objets porte sur l’identitÈ ( ==) ou une notion redÈ nissable de l’ÈgalitÈ (=). Cette redÈ nition de = permet de prendre en compte la copie super cielle ou la copie en profondeur.
Prenons l’exemple d’un ensemble de points, dÈclarÈs comme suit.
| p1 p2 p3 s1 s2 s3 |  » variables locales \`a l ‘ expression  »
p1 Point x: 5 y: 6. « version instanciation  »
p2 7@8. « version littÈrale  »
p3 p1.
s1 Set new.
s1 add: p1; add: p2; add: p3.
s2 s1 shallowCopy.
s3 s2 deepCopy.
s4 Set new.
s4 add: s1; add: s2; add: s3.
s4 printString
Le rÈsultat est ‘Set(Set(5@6 7@8) Set(5@6 7@8) Set(5@6 7@8))’
Noter que le type ensemble est gÈnÈrique et peut contenir toutes sortes d’objets. L’ajout de l’occurrence p3 dans s1 n’a pas eu lieu car p1 y Ètait dÈjà et que les ensembles ont des ÈlÈments en un seul exemplaire.
Examinons dans la gure 2 l’e et des di Èrentes copies et a ectation.

HÈritage

L’innovation la plus importante du modÉle objet est l’hÈritage. Voici une dÈ nition extraite de [Mey97].
DÈ nition 6.1 (hÈritage) L’hÈritage est un mÈcanisme permettant de dÈ nir une nou-velle classe (la sous-classe) à partir d’une classe existante (la super-classe) par extension ou restriction.
L’extension se fait en rajoutant des mÈthodes dans le comportement ou des variable d’ins-tances dans la structure. Par exemple, un employÈ est une personne qui a un contrat de travail. La restriction consiste à rÈduire l’espace des valeurs dÈ nies par la classe en posant des contraintes (conditions logiques à vÈri er) sur ces valeurs. Par exemple, un carrÈ est un rectangle dont les quatre cÙtÈs sont Ègaux.
L’hÈritage induit le polymorphisme : une instance de la sous-classe est aussi une instance de la super-classe. Cette instance peut donc utiliser sans les dÈ nir les mÈthodes de la super-classe.
Dans la pratique, l’hÈritage peut Ítre utilisÈ à tort et à travers (il y a parfois mÍme confusion entre hÈritage et utilisation). On peut redÈ nir les mÈthodes et changer leur pro ls. On doit donc donner des rÉgles prÈcises de contrÙle de l’hÈritage pour conserver un contrÙle de type s˚r. Des rÉgles ont ÈtÈ donnÈes dans [Car88, Mey97, ACR94].
Smalltalk autorise uniquement l’hÈritage simple : chaque classe hÈrite d’au plus une super-classe. La structure est hÈritÈe. Les variables sont redÈ nissables implicitement puisque le typage est dynamique. Par contre, une variable dÈclarÈe dans une super-classe ne peut Ítre redÈclarÈe dans la sous-classe. Les mÈthodes sont systÈmatiquement hÈritÈes des super-classes. Elles sont redÈ nissables.
L’unique source du graphe d’hÈritage est la classe Object : toutes les classes hÈritent de cette classe. Elle mÍme hÈrite de l’objet indÈ ni nil.

Recherche de mÈthode

Lors d’un envoi de message expr sÈl args, le mÈcanisme suivant est exÈcutÈ.
1. le receveur est calculÈ par Èvaluation de l’expression expr
2. la mÈthode de sÈlecteur sÈl est recherchÈe à partir de la classe du receveur (classe courante).
(a) si elle est trouvÈe, elle est appliquÈe avec les arguments arguments
(b) sinon la mÈthode de sÈlecteur sÈl est recherchÈe dans la super-classe de la classe courante et ainsi de suite jusqu’à la trouver ou arriver dans la classe Object.
(c) si la recherche Èchoue dans la classe Object, alors le message doesNotUnderstand: est envoyÈ avec comme paramÉtre le sÈlecteur sÈl. Nous rejoignons là le problÉme du traitement des exceptions .
L’utilisation de rÈcursion par la pseudo variable self apporte ici toute sa puissance : la mÈthode la plus spÈci que sera celle utilisÈe à l’exÈcution.

Super mÈthode

Elle permet de combiner les di Èrentes dÈ nitions d’une mÈthode par la pseudo-variable super. Cette caractÈristique est liÈe à la recherche de mÈthode : la recherche de la mÈthode est double. La premiÉre recherche fournit la mÈthode principale qui se trouve dans une classe Classe qui est soit la classe du receveur soit une super-classe de la classe du receveur. Avec la pseudo-variable super, l’interprÈteur commence alors une seconde recherche de la mÈthode à appliquer. L’Èvaluation des paramÉtres se fait sur le rÈsultat de cette seconde recherche. Par exemple supposons la hiÈrarchie de classes et d’instances de la gure 3. La Éche simple reprÈsente la relation d’instanciation. La Éche simple reprÈsente la relation d’hÈritage. L’Èva-luation de l’envoi de message obj m1 a che hello bas sur la console. L’Èvaluation de l’envoi de message obj m2 a che hello haut sur la console. Dans l’alternative (A), l’envoi de mes-sagesobj m boucle. Dans l’alternative (B), l’envoi de messagesobj m a che hello bas sur la console.

Instanciation et classes abstraites

La mÈthode d’instanciation par dÈfaut est la mÈthode de classe new. Plusieurs variantes existent selon les paramÉtres possible. Cette mÈthode est dÈ nie dans la classe Object redÈ nie dans de nombreuses sous-classes d’Object. En gÈnÈral, sa dÈ nition se fait en appelant une mÈthode d’instance initialize qui initialise les valeurs par dÈfaut de l’objet crÈÈ. Voici un exemple classique.
new
« mÈthode d’ instanciation  »
« super new initialize
Les classes abstraites sont utiles à la structuration du graphe d’hÈritage. Elles permettent de factoriser des comportements communs de haut-niveau. Par exemple, la classe Magnitude (Comparable en Ei el) rassemble tous les objets munis des opÈrations de comparaison ( =,>, >=, etc.).
DÈ nition 6.2 (classe abstraite)
Une classe abstraite est une classe non feuille du graphe d’hÈritage et qui n’est jamais instanciÈe dans le systÉme.
Par exemple considÈrons des Ètudiants et des enseignants. La classe des personnes est une classe abstraite, en e et un individu particulier sera instanciÈe à partir d’une des sous-classes spÈci ques. La classe Personne dÈ nit le comportement commun à toutes ses sous-classes. Classe abstraite et mÈtaclasse sont parfois confondus, à tort : une classe abstraite peut Ítre une mÈtaclasse ou n’Ítre qu’une classe ordinaire et vice-versa. Nous pouvons dire qu’une classe abstraite est un n˜ud interne du graphe d’hÈritage et une mÈtaclasse un n˜ud interne du graphe d’instanciation.
Il n’y a pas de distinction entre classe abstraite et classe instanciable en Smalltalk. Cette distinction est forcÈe en redÈ nissant la mÈthode new. Nous ne ferons qu’indiquer la di Èrence en commentaire. Les mÈthodes abstraites sont implantÈes par self subclassResponsability. Le masquage est possible en Smalltalk par self shouldNotImplement.
Nous expliquerons plus en dÈtail le mÈcanisme d’instanciation et le graphe d’instanciation dans la section 9.

Variables et mÈthodes de classe

Dans les langages de classes on utilise parfois la terminologie mÈthode et variable d’ins-tance ou mÈthode et variable de classe. Une mÈthode de classe, par opposition à une mÈthode d’instance est une mÈthode prÈvue pour s’appliquer à une classe et non pas à une instance. C’est le cas par exemple de la mÈthode new. Les variables de classes sont utilisÈes pour reprÈ-senter des informations commune à l’ensemble des instances d’une classe. Si l’information n’est visible qu’en lecture alors une mÈthode d’instance est une solution su sante. Une variable de classe est une variable qui est partagÈe (lecture et/ou Ècriture) par toutes les instances de cette classe. Il est possible de la voir comme appartenant à la classe et non plus à ses instances. La prÈsence de mÈta-objets facilite la description de variables et de mÈthodes de classes. En l’absence de mÈta-objets, les variables et mÈthodes de classe ne sont pas accessibles par envoi de message habituel : il s’agit d’opÈrations primitives. Nous approfondissons ces concepts dans les sections 10 et 9.

1 Introduction 
1 Introduction à Smalltalk-80
2 Le modèle à objets de Smalltalk-80 
1 Concepts et principes de base
2 Objet et classe
3 Envoi de message
4 Eléments du langage
5 Aectation, égalité, copie
6 Héritage
7 Visibilité des attributs
8 Méthodes comme des objets
9 Méta-objets
10 Dénition d’une classe
3 La programmation avec Smalltalk 
1 Exemple introductif
2 Quelques hiérarchies de classes
4 L’environnement de programmation de Smalltalk-80 
1 Mise en route
2 Outils principaux et fenêtres de l’environnement
3 Représentation textuelle du code
4 Programmation avec VisualWorks
5 Le modèle MVC 
1 Principes
2 Architecture MVC
3 Exemples d’utilisation du MVC
4 Précisions sur le MVC
5 Interfaces MVC avec VisualWorks
6 Le développement d’applications avec VisualWorks 
1 Dessin de l’interface
2 Création des classes du modèle
3 Liaison entre le modèle et l’interface
4 Vérication et compléments
5 Exécution et tests
6 Bilan
7 Conclusion 
A Exercices 
1 Langage
2 Classes
3 Programmation à objets
4 Applications
5 Un peu plus
B Compléments
1 La souris
2 Références autour de Smalltalk
3 VisualWorks 3.0/linux
C Solution des exercices
1 Conception et programmation d’une gestion de match de tennis
2 Générateur de compilateurs