Programmation Objet Avec Java

Transcription

1 Ecole d Ingénieurs de l Etat de Vaud Programmation Objet Avec Java 1er septembre 2002 Prof. Eric Lefrançois

2 ELS - 27 octobre Entete.fm

3 POO avec Java - I - Contenu 1 PRÉAMBULE 1 2 OBJETS ET TYPES ABSTRAITS LA PROGRAMMATION-OBJET: NOTION «D OBJET» 4 Un exemple: un objet de type «Rectangle» 4 Le cycle de vie d un objet TYPE ABSTRAIT: DÉFINITION 7 Un type abstrait définit une «structure de données».. 7 Un type abstrait est défini par un «ensemble d opérations».. 8 Définition du type abstrait «Rectangle» en Java 11 Implémentation du type abstrait en Java 13 Création de l objet: l opérateur «new» 15 Destruction de l objet: le message «finalize()» 15 Structure d une classe Java 16 Encapsulation de la structure d informations 17 Un type abstrait peut être défini directement par une classe 18 Type courant et type déclaré 18 Interface ou classe? 20 Une interface pour déclarer des constantes de configuration SÉMANTIQUE DES OPÉRATIONS 24 Description informelle de la sémantique 25 Description formelle de la sémantique 25 La notion «d expression» 25 Exprimer la sémantique des opérations 27 La programmation «par contrat» 28 Moyens mis à disposition en Java: instruction «assert» 29 Un exemple de programmation par contrat avec l opération «agrandir» DÉFINIR LA STRUCTURE DE DONNÉES: LES TYPES DE JAVA 31 Les types primitifs 32 Les types «objets» 34 Partage d objets, copie superficielle et copie profonde 35 Les primitifs sont manipulés par valeur 35 Les objets sont manipulés par référence 36 Copie d objets 36 Passage de paramètres 38

4 e-quest Analyse - II VARIABLES DE CLASSES ET VARIABLES D INSTANCE 39 Initialisation d'une variable de classe 41 Accéder aux variables de classe et aux variables d instance 41 Le constructeur de classe POURQUOI «ABSTRAIT»? INTÉRÊT DES TYPES ABSTRAITS 42 On s intéresse d abord aux opérations.. 42 Indépendance par rapport à l implantation.. 43 Un exemple.. ré-implantation de la classe «Rectangle» LA PROGRAMMATION OBJET ET LES TYPES ABSTRAITS 45 Programmation objet versus programmation procédurale 45 Un objet est-il un type abstrait? 47 Classes et types abstraits LA STRUCTURE D UN PROGRAMME 48 Les paquetages 48 Organisation des fichiers sources 50 Amorce de l application: la classe principale (main) 50 3 HÉRITAGE ET POLYMORPHISME JAVA ET LE MÉCANISME D HÉRITAGE 54 Héritage simple contre héritage multiple 54 Héritage simple en Java 56 Un exemple théorique 58 Héritage: quel intérêt? 59 Une meilleure structuration du programme 59 La réutilisation de code 59 L'héritage et l'utilisation de la mémoire 59 Edition de liens dynamique 60 Objets: type de déclaration et type courant UN BILAN SUR LES MODES DE PROTECTION 64 Encapsulation 65 Le mode privé: «private» 65 Le mode public: «public» 66 Le mode protégé: «protected» 66 Le mode «paquetage»: mode par défaut 68 Conseils et recommandations ENCHAÎNEMENT DES CONSTRUCTEURS 71 Invocation implicite du constructeur de la superclasse 71 Le constructeur par défaut BIEN UTILISER L'HÉRITAGE 74 L'héritage, vu comme un outil de spécialisation 74 La relation «est-un» 77 Le sous-typage 78 Rappel : la notion de type 79 Notion de sous-type 79 La règle de substitution LA REDÉFINITION DES MÉTHODES 80 Redéfinition et surcharge: parfois la confusion 80 Redéfinition: répondre à la règle de substitution 82 Premier corollaire: est-il possible de changer le mode de protection? 83

5 e-quest Analyse - III - Deuxième corollaire: les exceptions et la redéfinition 84 Interdire la redéfinition et bloquer l héritage 84 Les «méthodes finales» 84 Les «classes finales» LE POLYMORPHISME 85 Généralités 85 Comparons Java, Smalltalk et C++ 86 De l'intérêt du polymorphisme 87 Méthodes et classes abstraites MASQUAGE D UNE VARIABLE D INSTANCE LE MOT-CLÉ «SUPER» VARIABLES DE CLASSE ET HÉRITAGE MÉTHODES DE CLASSE ET HÉRITAGE 95 4 LES MODÈLES DE CONCEPTION EN PRÉLIMINAIRE LE MODÈLE MVC : «MODELE-VUE-CONTRÔLEUR» 98 Modèle 99 Vue 99 Relations entre le MODELE et les VUES 101 Le modèle «Observateur» 101 Diagramme de classe 102 Une classe «Observable» réutilisable 102 Diagramme de séquence 103 Contrôleur LE MODÈLE «OBSERVATEUR» LE MODÈLE «COMPOSITE» 104 Un exemple: une image graphique 105 Un autre exemple : la hiérarchie des composants de la librairie «awt» de Java OBJETS ACTIFS GÉNÉRALITÉS SUR LES THREADS 110 Concurrence ou parallélisme? 113 Mise en oeuvre des threads en Java LES THREADS DE LA MACHINE VIRTUELLE DIAGRAMME D ÉTATS ET DE TRANSITIONS 117 Construction d un thread 117 Lancement d un thread: start() 117 Blocage d un thread (sleep(), suspend() et entrée-sortie) 119 Mort d un thread 120 Récupération d un thread «mort» par le garbage collector 120 Contrôler l état d un autre thread: isalive() 121 Attendre la terminaison d un thread: join() RÉALISER DES OBJETS ACTIFS EN JAVA 121 Les objets passifs 121 Le objets actifs 122 Réalisation d un «objet actif» en Java 122 Méthode no1: par dérivation de la classe «Thread» 123

6 e-quest Analyse - IV - Méthode no2: par implémentation de l'interface «Runnable» SCHEDULING: POLITIQUE D ALLOCATION DU PROCESSEUR 124 La priorité des threads 124 Règles d ordonnancement des threads 125 Le modèle préemptif de Java 127 En conclusion EXCLUSION MUTUELLE: VERROUILLAGE D UN OBJET 129 Le mot-clé synchronized 131 Java et les moniteurs 131 Fermer le verrou 132 Ouvrir le verrou 133 Un «bloc synchronisé» 133 Une «méthode synchronisée» 133 Blocs synchronisés ou méthodes synchronisées? 134 La synchronisation de méthodes statiques (méthodes de classes) RENDEZ-VOUS ENTRE THREADS 135 Sémantique de «wait()» 137 Sémantique de la méthode «notify()» 138 Sémantique de la méthode «notifyall()» 139 Un modèle standard pour utiliser «wait()» 139 Exemple: une file d'attente LES VARIABLES «VOLATILE» LES THREADS DÉMONS LES GROUPES DE THREADS LES MÉTHODES «STOP()», «SUSPEND()» ET «RESUME()» SONT DÉPRÉCIÉES DANS JAVA Les dangers du message stop(), comment le remplacer 144 Les dangers du message suspend(), comment le remplacer ANNEXES 147 Méthodes de la classe «Thread» 147 start() 147 stop() 147 sleep(...) 147 suspend () 148 resume() 148 isalive() 149 yield() 149 interrupt() 149 interrupted() 149 isinterrupted() 150 setdaemon() 150 isdaemon() 150 join() 150 Méthodes de la classe «Object» 150 wait(..) 150 notify() 151 notifyall() ETUDE DE CAS UNE APPLICATION CLIENT-SERVEUR153

7 e-quest Analyse - V ENTRÉES/SORTIES SOUS UNIX: LES SOCKETS 154 Les fichiers spéciaux 154 Les «sockets» 155 Communication fiable 155 Communication non fiable de paquets JAVA, LE MODÈLE CLIENT-SERVEUR ET LES SOCKETS 157 Le modèle «Client-Serveur» 157 Le modèle Client-Serveur de l'application «chat» 158 Liaisons UDP et connexions TCP-IP 158 Protocole TCP 158 Protocole UDP (datagrammes) 159 Principe d'utilisation des sockets TCP 160 Du côté «Client» 160 Du côté «Serveur» 160 Construire l'adresse IP 161 Fermeture de la connexion 163 Ouverture simultanée de plusieurs connexions 163 Transmettre et recevoir des informations au travers d'une socket ILLUSTRATION: LE PROGRAMME «CHAT» 165 Interface utilisateur 166 Côté «Serveur» 166 Côté «Client» 166 Le «Client»: diagramme des classes 169 Classe «Client» 170 Classe «ServeurEcouteur» 171 Classe «InterfaceUtilisateur» 171 Classe «FenetreApplication» 171 Le «Serveur»: diagramme des classes 172 Classe «Serveur» 173 Classe «Connexion» 173 Classe «ControleurConnexions» 173 Test de l'application 174 Risque d'interblocage ANNEXES 175 A0: Protocole Client - Serveur 176 A1: Le «Client»: diagramme des états et transitions 178 A2: Le «Serveur»: diagramme des états et transitions 179 A3: Listing du fichier Client: «Client.java» 180 A4: Listing du fichier Client: «ServeurEcouteur.java» 186 A5: Listing du fichier Client: «InterfaceUtilisateur.java» 189 A6: Listing du fichier Serveur: «Serveur.java» 194 A7: Listing du fichier Serveur: «Connexion.java» 196 A8: Listing du fichier Serveur: «ControleurConnexions.java» 199 A9: Classe «Socket» 200 A10: Classe «ServerSocket» 201 A11: Classe «InetAddress» 201 Annexe A UML: UN RÉSUMÉ DU DIAGRAMME DE CLASSES LES DIAGRAMMES DIAGRAMMES DE CLASSES CLASSES 205

8 e-quest Analyse - VI - Nom de la classe 205 Attributs 206 Opérations(Méthodes) 206 Variables et méthodes de classe 206 Visibilité des éléments 207 Autres propriétés des éléments CLASSES UTILITAIRES OBJETS 208 Nom de l'objet 208 Valeur de l'objet 208 Multiplicité MULTIPLICITÉ DES OBJETS, EXEMPLE D'UN FEU DE LA CIRCULATION ASSOCIATIONS 209 Nom de l'association 210 Rôle des classes 210 Cardinalité 210 Associations multiples 211 Association-OU 211 Agrégations 211 Cardinalité du composite 212 Associations ternaires 212 Propriété de «navigabilité» HÉRITAGE 214 Généralisation-OU 214 Généralisation-ET 214 Type de partition PAQUETAGES (PACKAGES) 216 Référence à un autre paquetage 217 Dépendances entre paquetages 217 Annexe B INDEX 219

9 POO avec Java Préambule 1 Préambule Ce manuel est destiné aux étudiants désireux d'être introduits aux concepts qui forment la base de la philosophie objet. Dans une première partie, nous commencerons par couvrir les notions d'objet et de type abstrait. Nous continuerons par une discussion en profondeur sur l'héritage et le polymorphisme, puis nous nous attarderons sur la présentation détaillée de quelques uns des modèles de conception fondamentaux qui se rattachent au paradigme objet comme les modèles «Observateur», «MVC» (Modèle-Vue-Contrôleur), etc.. Enfin, nous terminerons par une étude de cas, une application Client-Serveur distribuée, qui nous permettra notamment d'illustrer la structure d'un programme comportant des objets concurrents. Les exemples développés au travers du manuel sont exprimés en Java, un langage qui a su faire la synthèse de différents outils qui ont connu leur heure de gloire comme Smalltalk ou C++. La structure des programmes, les diagrammes d'état, diagrammes de classes et de séquence sont présentés en utilisant le formalisme UML («Unified Modeling Language») dont quelques aspects sont présentés en annexe. ELS - 14 novembre 2002

10 POO avec Java Préambule ELS - 14 novembre 2002

11 POO avec Java Objets et types abstraits 2 Objets et types abstraits Pour introduire le lecteur à la notion d objet, nous nous appuierons essentiellement sur la notion de type abstrait, - un concept considéré comme un classique de la programmation -, que nous aborderons dans une perspective propre à la programmation orientée objet. Se basant sur les concepts élaborés par [Booch] 1, nous commencerons par une première définition du concept d objet. Puis, considérant dans une première approche qu un objet peut être considéré comme une structure de données définie par un ensemble d opérations, nous enchaînerons par une présentations du concept de type abstrait. Nous terminerons en montrant que le concept d objet présente un certain nombre de richesses qui sont absentes du concept de type abstrait. Nous citerons notamment: l héritage de la structure et du comportement, 1. Grady Booch - Auteur de nombreux ouvrages de référence portant sur la conception orientée objet

12 POO avec Java Objets et types abstraits le fait qu un objet peut représenter autre chose qu une structure de données «passive». En effet, un objet peut modéliser un «automate», qui, associé à un programme spécifique peut s exécuter en concurrence avec les autres objets du programme. 2.1 LA PROGRAMMATION-OBJET: NOTION «D OBJET» En voulant formaliser le paradigme objet, [Booch] a défini l objet informatique comme un élément caractérisé par 3 composantes: 1. Un état (ou une «valeur»): état de la mémoire occupée par l objet; 2. Un comportement: ensemble des opérations qui permettent d agir sur l objet; 3. Une identité: l objet existe indépendamment de sa valeur Un exemple: un objet de type «Rectangle» Imaginons une application graphique qui manipule différentes sortes de figures: des cercles, des rectangles, des carrés,.. Du point de vue du programmeur qui aura développé ce logiciel, ces figures sont considérées comme des objets.. Considérons par exemple l objet «r1», un objet de type «Rectangle». Un tel objet est caractérisé par 4 informations variables: les coordonnées x et y de son point supérieur gauche, sa largeur et sa hauteur. (0,0) y x X hauteur largeur Y 1. «r1» a un état: la valeur prise par les 4 informations qui le caractérisent; Par exemple: <x=3, y=4, largeur = 20, hauteur = 10>. 2. «r1» a un comportement: ensemble des opérations qui permettent d agir sur «r1»; Par exemple: r1 = new Rectangle (3, 4, 20, 10); Création de «r1» avec la valeur initiale <3, 4, 20, 10> r1.déplacer (5, 6); Pour déplacer le rectangle de «5» en X, et de «6» en Y. Son état a été modifié. Il vaut maintenant <8, 10, 20, 10> r1.agrandir (3); Pour augmenter de «3» la largeur et la hauteur du rectangle.

13 POO avec Java Objets et types abstraits taille = r1.getlargeur(); Pour retourner la largeur du rectangle, affectée à la variable «taille» Les 3 opérations «déplacer», «agrandir» et «getlargeur» ont été invoquées en «envoyant un message» à l objet. Notons au passage la syntaxe d un envoi de message: <objet>.<message_avec_paramètres> 3. «r1» a une identité: Le rectangle «r1» existe, indépendamment de sa valeur. Sa valeur peut être modifiée notamment par les opérations «déplacer» et «agrandir». «r1» est une variable qui sert à désigner le rectangle. Le même rectangle pourrait être désigné par une autre variable. Ce rectangle existe indépendamment de la variable ou des variables qui servent à le désigner dans le programme. Par exemple: r1 = new Rectangle (3, 4, 20, 10); Le nouveau rectangle de valeur <3,4,20,10> est désigné par la variable «r1» <3,4> r r2 = r1; Le même rectangle est désigné par une deuxième variable, la variable «r2» <3,4> r1 r r1 = new Rectangle (3, 4, 20, 10); Notre rectangle continue d exister, il est toujours désigné par la variable «r2». La variable «r1» est maintenant utilisée pour désigner un autre rectangle, qui, - par hasard -, a la même valeur que le premier rectangle. r1 <3,4,20,10> <3,4,20,10> r2

14 POO avec Java Objets et types abstraits Définition 1: La notion d Objet Un objet est caractérisé par 3 éléments: 1. un état (ou une «valeur») Un objet occupe une place en mémoire. Cette place mémoire permet de stocker la valeur courante des différentes variables qui le caractérisent. Ainsi, un objet rassemble un certain nombre d informations. On dit qu un objet est une structure de données. Le mot «donnée» est synonyme «d information». En programmation, chaque information (chaque «donnée») est représentée par une variable. 2. un comportement Un objet réagit à un certain nombre d opérations qui permettent «d agir sur» cet objet. Le programmeur enclenche de telles opérations en «envoyant un message» à l objet. En réponse, l objet pourra modifier son état, et pourra agir sur d autres objets en leur envoyant des messages à son tour. Notons que le comportement d un objet peut différer selon son état, ce qui apparaît dans le paragraphe suivant [Voir paragraphe - Le cycle de vie d un objet - page 6] 3. une identité L identité d un objet caractérise le fait que l objet existe: il possède un «cycle de vie» qui commence par sa création et se termine par sa destruction. Dans le contexte de la programmation, dire qu un objet «possède une identité», c est affirmer que cet objet existe, et que cette existence est absolument indépendante de la valeur de cet objet et de la façon dont on le désigne. Autrement dit, l objet est un «individu» unique, dont la valeur peut être modifiée, et qui peut avoir plusieurs noms. Notons que deux objets différents peuvent avoir la même valeur! Le cycle de vie d un objet La vie d un objet peut être caractérisée par un diagramme d états et de transitions, qui présentera la création de l objet, sa destruction, ainsi que les différents états caractérisés chacun par un comportement spécifique de l objet. Voici par exemple le diagramme d états et de transitions d une pile (LIFO), représenté en utilisant la notation UML. Un tel objet est susceptible de répondre aux 3 messages suivants: 1. empiler(unelement) - Procédure 2. depiler(): unelement - Fonction 3. estvide(): boolean - Fonction

15 POO avec Java Objets et types abstraits La réception de l un ou l autre de ces 3 message a un effet différent, dépendant directement de l état dans lequel se trouve la pile. Figure 1: Cycle de vie de l objet "Pile" création (new) estvide() dépiler()/ Exception Vide dépiler() empiler(élément) estvide() Non vide empiler(élément) dépiler() Pleine estvide() destruction empiler(élément)/ Exception destruction 2.2 TYPE ABSTRAIT: DÉFINITION La notion de type abstrait, très classique et très ancienne, est à la base du paradigme objet. Nous verrons ainsi que les propriétés des types abstraits se rapprochent énormément de la notion d objet présentée en début de chapitre. Définition 2: Types abstraits Un type abstrait définit une structure de données par un ensemble d opérations applicables aux objets de ce type et une description sémantique de ces opérations. Un type abstrait définit une «structure de données».. Prenons l exemple du type abstrait «Rectangle». Un objet de type «Rectangle» sera caractérisé par 4 informations: les coordonnées «x» et «y» de son point supérieur gau-

16 POO avec Java Objets et types abstraits che, sa largeur et sa hauteur. Ces 4 informations seront variables: leur valeur pourra être modifiée. Ces 4 informations, prises ensemble, constituent ce qu on appelle une structure de données. Un type abstrait est défini par un «ensemble d opérations».. Définition 3: Opérations Pour un type abstrait, on distingue en général trois catégories d opérations: 1. les constructeurs; Ces opérations sont exécutées au moment de la création de l objet. Elles servent à donner un état initial à l objet: une valeur initiale aux différentes variables de la structure de données. Typiquement, on rencontrera 3 espèces de constructeurs: le constructeur sans paramètre, qui donnera une valeur par défaut à l objet, un ou plusieurs constructeurs avec paramètres et enfin un constructeur de copie qui crée un objet en copiant la valeur d un objet passé en paramètre. 2. les modificateurs; Ecrits souvent sous la forme setxxx(..), ces opérations changent l état de l objet. 3. les observateurs (ou accesseurs), ou encore interrogateurs; Ecrits souvent sous la forme getxxx(..), ces opérations permettent «d interroger» l objet et retournent des informations concernant l état de l objet. Par exemple, le type abstrait «Rectangle» peut être caractérisé par l ensemble des opérations suivantes: Tableau 7: Opérations du type «Rectangle» Opération Catégorie Explication new Rectangle () (1) Constructeur Création d un nouveau rectangle. L état initial de cet objet aura une valeur «par défaut», comme par exemple <0,0,0,0>. new Rectangle (3, 4, 20, 10) (1) Constructeur Création d un nouveau rectangle. Les 4 paramètres du constructeur permettent de spécifier une valeur initiale pour les coordonnées «x», «y» du point supérieur gauche, pour la largeur et la hauteur.

17 POO avec Java Objets et types abstraits new Rectangle (Rectangle r) Tableau 7: Opérations du type «Rectangle» Opération Catégorie Explication (1) Constructeur Création d un nouveau rectangle. Par copie du rectangle «r» (paramètre) agrandir (5) (2) Modificateur Pour agrandir le rectangle. La largeur et la hauteur du rectangle seront augmentées de la valeur «delta», définie dans le paramètre de l opération deplacer (3, 4) (2) Modificateur Pour déplacer le rectangle. Les deux paramètres servent à spécifier la valeur du déplacement en X, respectivement en Y getlargeur (10) (2) Modificateur Pour spécifier la largeur du rectangle sethauteur (20) (2) Modificateur Idem pour la hauteur setx (5) (2) Modificateur Idem pour X sety (4) (2) Modificateur Idem pour Y getlargeur() (3) Accesseur Cette opération, sans paramètre, «retourne» la largeur du rectangle. gethauteur() (3) Accesseur Idem, pour la hauteur. getx() (3) Accesseur Idem pour X gety() (3) Accesseur Idem, pour Y contientlepoint (5, 6) (3) Interrogateur Cette opération retourne «true», si le point, dont les coordonnées sont passées en paramètres, est inscrit dans le rectangle. Dans le cas contraire, cette opération retourne «false». Définition 4: Caractéristiques d une opération Une opération est définie par 3 éléments: 1. son nom; 2. la liste des paramètres, avec leur type; 3. le type de la valeur retournée par l opération.

18 POO avec Java Objets et types abstraits A titre d exemple, reprenons le type «Rectangle».. Tableau 8: Caractéristiques des opérations du type Rectangle, définies en UML a Nom de l opération Paramètres Type retourné Catégorie new Rectangle (x: int, y: int, largeur: int, hauteur: int) -- 1: Constructeur new Rectangle () -- pas de paramètre -- 1: "" "" new Rectangle (r: Rectangle) -- 1: "" "" agrandir (delta: int) -- 2:Modificateur déplacer (deltax: int, deltay: int) -- 2: "" "" setlargeur (l: int) -- 2: "" "" sethauteur (h: int) -- 2: "" "" setx (x: int) -- 2: "" "" sety (y: int) -- 2: "" "" gethauteur () -- pas de paramètre int 3: "" "" getx () -- pas de paramètre int 3: "" "" gety () -- pas de paramètre int 3: "" "" getlargeur () -- pas de paramètre int 3: Observateur contientle- Point (coordx: int, coordy: int) boolean 3: "" "" a. UML est un langage de modélisation standard, indépendant des langages programmation Chaque paramètre est défini par son type. Dans notre exemple, il s agit toujours du type «int» qui représente les entiers. Notre exemple met en évidence les deux propriétés suivantes: Propriété 1 Les constructeurs et les modificateurs ne retournent aucune valeur. Le rôle de ces opérations se borne uniquement à modifier l état de l objet. En programmation, ces opérations sont mises en œuvre par des procédures.

19 POO avec Java Objets et types abstraits Propriété 2 Les observateurs retournent toujours une valeur. Ces opérations se contentent d interroger l objet. Elles ne modifient pas l état de l objet. En programmation, objet, ces opérations sont mises en oeuvre par des fonctions. Remarquons qu en langage UML 1, ces opérations seront définies de la manière suivante: new Rectangle (x: int, y: int, largeur: int, hauteur: int) new Rectangle () déplacer (deltax: int, deltay: int) contientlepoint (coordx: int, cordy: int): boolean... Notamment, on notera qu en UML: les parenthèses sont obligatoires, même s il n y a pas de paramètre; chaque paramètre obéit à la syntaxe: <nom>:<type>; le type retourné est indiqué à la fin: <type> Définition du type abstrait «Rectangle» en Java En Java, un type abstrait peut être défini directement au moyen d une classe [Voir paragraphe - Implémentation du type abstrait en Java - page 13], mais c est la notion d interface, propre à Java qui s en rapproche le plus. Programme 1: Le type abstrait: une interface interface Rectangle_I { // Modificateurs public void agrandir(int delta); public void déplacer (int deltax, int deltay); // Observateurs public int getx (); public int gety (); public int getlargeur(); public int gethauteur (); public boolean contientpoint (int px, int py); 1. UML est un langage de modélisation standard, indépendant des langages programmation

20 POO avec Java Objets et types abstraits Une interface, comme son nom l indique, décrit simplement la liste des méthodes mises à disposition par le type abstrait, en spécifiant leur nom, et la manière de les utiliser (paramètres et type retourné). une interface pour déclarer des variables ou des paramètres de méthodes Une interface est simplement une espèce de «mode d emploi»: une fois définie, une interface pourra être utilisée pour déclarer des variables ou plus généralement des paramètres de méthodes qui désigneront des objets susceptibles de répondre aux opérations spécifiées dans l interface. Comme par exemple: Rectangle_I r; // «r» est une variable. La variable «r» sera utilisée pour désigner un objet de type «Rectangle_I». A ce stade, il n y a pas eu de création d objet: cette variable vaut «null», elle ne désigne pour l instant aucun objet. : : public void unemethode (Rectangle_I r) { De manière générale, les interfaces sont utilisées pour déclarer des paramètres de méthodes. Dans le cadre de la procédure «unemethode», «r» désignera un objet répondant exclusivement aux messages spécifiés dans l interface «Rectangle_I» /* code de la méthode «unemethode» */ une interface ne définit aucun constructeur On remarquera qu une interface ne donne aucune information au sujet des constructeurs potentiels. Une interface ne permet pas de créer un objet. En effet, la création de l objet dépendra directement de la manière dont sera «implémentée» l interface et notamment de la structure de données mise en oeuvre, il n est donc pas prévu de constructeur à ce stade. Notamment, lors de la création d un objet, le système devra lui réserver une zone mémoire, qui contiendra sa valeur. La taille de cette zone mémoire et sa valeur dépend bien entendu de la manière dont sera implémentée la structure de données.

21 POO avec Java Objets et types abstraits Pour créer l objet, il faudra réaliser l implémentation de l interface au moyen d une classe. Ce que nous verrons dans le point suivant. Et quand l objet aura été créé, il sera possible de lui envoyer l un ou l autre des messages spécifiés dans l interface. Comme par exemple: r.déplacer (4, 5); r.agrandir (4); int unentier; // Déclaration d une variable de type entier unentier= r.getlargeur(); // «unentier» vaut la largeur // actuelle du rectangle Implémentation du type abstrait en Java L interface décrit dans le programme [ Programme 1:, page 11] permet de déclarer un objet, mais pas de le créer. Pour créer un objet de type «Rectangle_I», il nous faut maintenant réaliser le type abstrait. Dans le jargon informatique, on dira implémenter le type abstrait. En Java, on utilisera à cette fin le mécanisme de classe. Programme 2: Implémentation de l interface class Rectangle implements Rectangle_I{ // Variables d instance private int x; private int y; private int lg; private int ht; // Constructeur (s) public Rectangle () { x = y = 0; lg = ht = 0; // Point supérieur gauche // Largeur et Hauteur public Rectangle (Rectangle r) { x = r.x; y = r.y; lg = r.lg; ht = r.ht; // ou: this (r.x, r.y, r.lg, r.ht); // utilisation du constructeur avec paramètres public Rectangle(int px, int py, int largeur,int hauteur) { x = px; y = py; lg = largeur; ht = hauteur; // Modificateurs public void agrandir(int delta) { lg = lg + delta; ht = ht + delta;

22 POO avec Java Objets et types abstraits public void déplacer (int deltax, int deltay) { x = x + deltax; y = y + deltay; public void setx(int x) {this.x = x; public void sety(int y) {this.y = y; public void setlargeur(int lg) {this.lg = lg; public void sethauteur(int ht) {this.ht = ht; // Observateurs public int getx () {return x; public int gety () {return y; public int getlargeur() {return lg; public int gethauteur () {return ht; public boolean contientpoint (int px, int py) { return (px > x) && (px < x+lg) && (py > y) && (py < y+ht); Une classe qui implémente une interface a la particularité: 1. d une part, de rappeler la définition du type abstrait en donnant la spécification des opérations applicables aux objets: void agrandir(int delta) void déplacer (int deltax, int deltay) int getx() int gety () d autre part, de réaliser le type abstrait en proposant une représentation de la structure de données au moyen des variables d instance: int x; int y; int lg; int ht; 3. et enfin, de terminer la réalisation du type abstrait en décrivant les instructions accomplies par chacune des opérations à l intérieur d une paire d accolades {..: void déplacer (int deltax, int deltay) { x = x + deltax; y = y + deltay;

23 POO avec Java Objets et types abstraits Nous pouvons maintenant créer véritablement un objet de type «Rectangle_I», la classe «Rectangle» a prévu à cet effet trois constructeurs: Programme 3: Création d objets Rectangle_I r1, r2, r3; Déclaration de 3 variables r1 = new Rectangle (); Création de l objet en utilisant le constructeur sans paramètre: la largeur, la hauteur ainsi que les coordonnées de son point supérieur gauche valent respectivement <0, 0, 0, 0> r2 = new Rectangle (3, 4, 20, 10); Création de l objet en utilisant le constructeur avec paramètres r3 = new Rectangle (r2); Création de l objet en utilisant le constructeur de copie: la largeur, la hauteur ainsi que les coordonnées de son point supérieur gauche valent respectivement <3, 4, 20, 10> Création de l objet: l opérateur «new» Nous explicitons ici le fonctionnement de l opérateur new du langage Java. Soit: r = new Rectangle (3, 4, 20, 10) ; La création de l objet r s effectue en 3 étapes : 1. Allocation d'une zone mémoire, avec initialisation Par exemple : private int x ;// "x" est initialisée à 0 (par défaut) private int y = 3 ;// "y" est initialisée avec 3 2. Invocation du constructeur (Rectangle(..)) De nouvelles valeurs peuvent être affectées aux variables d'instance. 3. Retour de la référence L opérateur new retourne pour finir la référence à l objet, affectée à la variable r Destruction de l objet: le message «finalize()» La destructiono de l objet est opérée par le ramasse-miettes (garbage collector). Cette opération est susceptible d arriver dès l instant où l objet n est plus référencé par aucune variable.

24 POO avec Java Objets et types abstraits Les dernières volontés de l objet.. Avant même de détruire l objet, le garbage collector lui envoie le message finalize(), lui donnant ainsi l occasion d accomplir ses dernières volontés. Par défaut, la méthode invoquée, - définie dans la classe Object -, ne fait rien, mais le programmeur peut la redéfinir ainsi : protected void finalize () throws Throwable { /*..Ecrire ici les dernières volontés de l objet..*/ super.finalize(); // «If you override finalize, your implementation of the // method should call super.finalize as the last thing it // does» Note d utilisation L utilisation de finalize(), qui joue le même rôle que le destructeur de C++, est effectuée très rarement en Java, du fait de l existence même du garbage collector Structure d une classe Java La déclaration d'une classe obéit à la syntaxe suivante : [Modificateurs de classe] class NomDeLaClasse [extends nomdelasuperclasse] [implements interface1, interface2,..] { [Variables] [Constructeurs] [Méthodes] Notons que les variables, constructeurs et méthodes peuvent être déclarés dans n importe quel ordre! Par convention, on préfère commencer par déclarer les variables, puis les constructeurs, pour finir par les méthodes. [Modificateurs de classe] public classe visible depuis un autre paquetage 1 1. Un paquetage est un ensemble de classes, regroupées concrètement dans un seul et même répertoire, portant lui-même le nom du paquetage.

25 POO avec Java Objets et types abstraits abstract classes abstraites [Voir paragraphe - Méthodes et classes abstraites - page 87] final classes non dérivables (héritage interdit) [extends nomdelasuperclasse]héritage simple [implements interface1, interface2,..]implémentation d interfaces Encapsulation de la structure d informations On remarquera que les différents éléments qui composent la classe «Rectangle» sont précédés par le mot-clé «public», ou encore par le mot-clé «private». // Variables d'instance private int x, y; private int lg,ht; // Constructeur (s) public Rectangle () { x = y = 0; lg = ht = 0; Rectangle() Rectangle(int x,..) Rectangle(Rectangle r) x y lg ht agrandir (int delta).. Les éléments «private» ont trait à la réalisation du type abstrait, et ne sont pas accessibles à l extérieur de la classe. Les éléments «public» sont au contraire accessibles par des méthodes situées à l extérieur de la classe: il s agit notamment des opérations qui pourront être accomplies sur les objets de type «Rectangle_I» et invoquées depuis l extérieur. Définition 5: Encapsulation L encapsulation consiste à «cacher» de l extérieur l implémentation d une structure d informations. Disons plus exactement que l encapsulation de la structure d informations décrite à l intérieur du type abstrait ou de la classe, est un mécanisme qui rend cette structure inaccessible depuis l extérieur. Son accès se fera uniquement par le biais des opérations qui lui sont applicables, c està-dire par les méthodes déclarées au sein de la classe et qui doivent, en revanche, être accessibles de l extérieur (donc déclarées avec le mot-clé public)

26 POO avec Java Objets et types abstraits Pourquoi encapsuler la structure d information, dans quel but? Nous renvoyons le lecteur en fin de chapitre [Voir paragraphe - Intérêt des types abstraits - page 42] Un type abstrait peut être défini directement par une classe Définition 6: Une classe définit un type de données Il n est pas nécessaire en Java de passer par la notion d interface: en donnant la liste de toute les méthodes applicables au type d objet, une classe définit un type de données. Il est donc possible de déclarer une variable à partir d une classe. En effet, comme le montre le programme 2, une classe a deux facettes: elle définit les opérations et elle les réalise. Comme elle définit les opérations, on peut l utiliser pour déclarer des variables. Ainsi, la variable «r» pourrait être déclarée directement à partir de la classe «Rectangle»: Rectangle r; // Déclaration à partir de la classe r = new Rectangle (); Type courant et type déclaré Le lecteur aura remarqué que l opérateur «new», invoqué pour créer l objet, a été appliqué à une classe, qui ne correspond pas forcément au type utilisé pour déclarer la variable: Rectangle_I r = new Rectangle (); <nom-du-type> <nom-variable> = new <nom-de-la-classe> Définition 7: Type courant et type déclaré En programmation objet, on distinguera très nettement les notions de type courant et de type déclaré. le type déclaré correspond au type qui a été utilisé pour déclarer la variable; le type courant correspond au type utilisé pour créer l objet désigné par la variable. Le type déclaré est connu par le compilateur: il spécifie la liste des opérations pouvant être appliquées à l objet. Le compilateur vérifie que c est bien le cas. Il refusera le programme si les propriétés du type déclaré ne sont pas respectées. En Java, le type déclaré peut être une classe ou bien encore une interface. Le type courant d un objet correspond toujours à une classe. Cette classe met à disposition les constructeurs qui auront permis de créer l objet.

27 POO avec Java Objets et types abstraits Comme l invocation de l opérateur «new» peut être opérée n importe où et n importe quand dans le programme, c est seulement à l exécution que sera connu le type courant de l objet. Le compilateur ne connaît que le type déclaré. La classe du type courant peut être la même que celle qui a été utilisée pour déclarer la variable: c est le cas le plus usuel. Il est possible toutefois que cette classe soit différente. Dans ce cas, il s agira: Soit d une classe implémentant l interface utilisé pour déclarer la variable; Soit d une sous-classe de la classe utilisée pour déclarer la variable. Une sousclasse est une classe «héritière»: le polymorphisme et l héritage, concepts propre à la programmation objet et que nous étudierons dans un prochain chapitre [Voir paragraphe - Java et le mécanisme d héritage - page 54], impliquent que le type courant d un objet ne soit connu qu au moment de l exécution du programme. Rectangle_I r1 = new Rectangle (3,4,20,10); Rectangle r2 = new Rectangle (3,4,20,10); Type courant = type de l'objet Le type courant est dynamique, connu uniquement à l'exécution Type déclaré = type de la variable Le type déclaré définit l'ensemble des opérations qui peuvent être accomplies sur la variable. Le compilateur vérifie que cette règle est respectée

28 POO avec Java Objets et types abstraits Voici un programme Java qui utilise la classe «Rectangle»: Rectangle_I r; // Déclaration d une variable r = new Rectangle (3, 4, 10, 20); Textes affichés r.déplacer (2, 2); System.out.println ("Largeur: " + r1.getlargeur()); System.out.println ("X: " + r1.getx()); r1.agrandir (3); System.out.println ("Largeur: " + r1.getlargeur()); System.out.println ("X: " + r1.getx()); Largeur: 10 X: 5 Largeur: 13 X: 5 if (r1.contientpoint (10, 10)) { System.out.println ("Contient <10, 10>"); else { System.out.println ("Ne contient pas <10, 10>"); Contient <10, 10> Interface ou classe? Dans une première approche, nous avons utilisé le mécanisme d interface en raison du fait que c est ce dernier qui, en Java, s apparente le plus au concept de type abstrait. Mais nous avons constaté que le mécanisme de classe convient parfaitement pour déclarer les types abstraits, si ce n est qu on mélange alors la définition du type d une part, et sa réalisation d autre part. Dans 95% des cas, en pratique, c est le mécanisme de classe qui sera utilisé. Ceci évitera bien des lourdeurs. Par exemple, typiquement, le type «Rectangle» serait déclaré ainsi: Programme 4: Une classe qui n implémente aucune interface class Rectangle { // Cette classe n implémente aucun interface private int x; private int y; private int lg; private int ht; // Point supérieur gauche // Largeur et Hauteur

29 POO avec Java Objets et types abstraits : : public Rectangle () { x = y = 0; lg = ht = 0; // Constructeur Si les classes suffisent, pourquoi utiliser des interfaces? La notion d interface est un concept spécifique à Java, et vient palier au fait que Java, contrairement à C++, ne connaît pas l héritage multiple. En revanche, la notion d interface offre à Java la possibilité d opérer le typage multiple: le type d une variable peut être multiple! A titre d exemple, considérons les déclarations suivantes.. Programme 5: Le typage multiple interface Rectangle-I { /* identique au programme [ Programme 1:, page 11]*/ interface ObjetGraphique { public void dessiner(); class RectangleA implements Rectangle_I { // implémentation de l interface Rectrangle_I : : voir [ Programme 2:, page 13] : // méthodes propres à la classe RectangleA public void dessiner() { /* instructions..*/ public void effacer() { /* instructions.. */ class RectangleB { // Pour des rectangle de taille et de position non modifiables private int x, y, lg, ht; public RectangleB (int x, int y, int lg, int ht) { this.x = x; this.y = y; this.lg = lg; this.ht = ht;

30 POO avec Java Objets et types abstraits public int getx() {return x; public int gety() {return y; public int getlargeur() {return lg; public int gethauteur() {return ht; class Fenetre implements Rectangle_I, ObjetGraphique { // Implémentation de l interface Rectangle_I : : Implémentation de toutes les méthodes de l interface : // Implémentation de l interface ObjetGraphique public void dessiner() { /* instructions */ // Méthode propre à la classe Fenetre public void effacer() { /* instructions */ Considérons maintenant quelques déclarations de variables: Rectangle_I ri = new RectangleA(); RectangleAra = new RectangleA(); RectangleB rb = new RectangleB (2, 3, 4,5); ObjetGraphique og = new Fenetre(); Fenetre f = new Fenetre(); Parmi ces variables, certaines ont des propriétés qui appartiennent à plusieurs types de données. Ainsi, suivant le rôle que joue chacune d entre elles à un moment donné du programme, - et ce rôle peut varier, tout comme les individus peuvent jouer plusieurs rôles au sein de la société -, les opérations qui leur seront appliquées appartiendront tantôt à un type de données X, tantôt à un type de données Y. Ainsi, l objet f «est-une» Fenetre. Mais on peut dire aussi que f «est-un» ObjetGraphique, ou que f «estun» Rectangle_I. Voici les types de données caractérisant chacune de ces variables: ri ra rb og f Rectangle_I Rectangle_I, RectangleA RectangleB ObjetGraphique ObjetGraphique Rectangle_I Fenetre Grâce à la notion de typage multiple, il est possible de réaliser des méthodes dont les paramètres, s ils sont de type interface, sont susceptibles de prendre des formes extrêmement variées.

31 POO avec Java Objets et types abstraits Ainsi, si nous considérons les deux méthodes décrites ci-dessous: public void m1 (ObjetGraphique o) { : o.dessiner(); : public void m2 (Rectangle_I r) { : r.déplacer(3); : Les invocations suivantes sont alors correctes. En effet, les paramètres effectifs utilisés ont chacun au moins un type (parmi les types multiples qui les caractérisent) qui correspondant au type du paramètre formel. m1(f); m1(og); m2(ra); m2(ri); Une interface pour déclarer des constantes de configuration En règle générale, les interfaces sont utilisées pour définir des liste d opérations. Il est toutefois possible d y définir des constantes symboliques comme par exemple la constante PI qui serait déclarées de la manière suivante: public static final double PI = ; Les constantes symboliques sont déclarées comme des variables (eh oui!) qui comportent une valeur d initialisation non modifiable. Il suffit donc de déclarer une variable en précisant qu elle est non modifiable au moyen du mot-clé final. Par convention d écriture, les constantes symboliques sont écrites en majuscules Les constantes de configuration d un programme peuvent être rassemblées dans une interface comme ci-dessous (pour un programme de jeu): interface Configuration { // Déclaration des constantes de configuration, accessibles // globalement par tout le programme public static final int NOMBRE_MAX_JOUEURS = 20; public static final int NOMBRE_MAX_ESSAIS = 3; Remarque: dans une interface, les mot-clés public, final et static sont implicites et n ont pas besoin d être écrits

32 POO avec Java Objets et types abstraits Les classes qui désirent utiliser ces constantes doivent alors le déclarer explicitement au moyen d une implémentation. Par ce biais, les constantes en question deviennent alors directement accessibles, comme par exemple: class Jeu implements Configuration { : public void run { while (NoEssai <= NOMBRE_MAX_ESSAIS) { : : Le fait de devoir opérer une implémentation spécifique de l interface est intéressant du point de vue de la lisibilité du programme puisque que l on peut repérer assez facilement toutes les classes dépendantes de la valeur des constantes de configuration. 2.3 SÉMANTIQUE DES OPÉRATIONS Jusqu à présent, nous avons présenté les opérations des types abstraits uniquement sous un angle «syntaxique». C est-à-dire que nous nous sommes préoccupé des règles à suivre pour écrire une opération: écrire le nom de l opération, puis ouvrir une parenthèse, écrire le ou les paramètres éventuels, etc.. Définition 8: Sémantique des opérations La sémantique est à la syntaxe ce que le «fond» et à la «forme». La sémantique des opérations s intéresse aux propriétés des opérations, elle s intéresse particulièrement: à ce que fait l opération, si cette dernière est utilisée correctement; aux conditions à respecter pour utiliser correctement l opération. Les conditions à respecter constituent ce qu on appelle les préconditions. Les postconditions représentent le résultat de l exécution de l opération. Définition 9: Préconditions Les préconditions sont des conditions à respecter: sur la valeur de l objet qui doit subir l opération, sur la valeur des paramètres de l opération. Si ces conditions ne sont pas respectées, l opération n a pas de sens: elle ne doit pas être appliquée. Si malgré tout, cette opération était appliquée, son résultat serait tout à fait indéfini. En d autre termes, le programme «planterait».

33 POO avec Java Objets et types abstraits Définition 10: Postconditions Les postconditions sont des faits qui sont toujours vrais après l exécution de l opération, à condition évidemment que les préconditions aient été respectées. Ces faits concernent la nouvelle valeur de l objet. En gros, les postconditions décrivent la fonction même, réalisée par l opération. Intéressons-nous maintenant à la manière de décrire les préconditions et les postconditions associées à une opération Description informelle de la sémantique Dans certains cas, un texte descriptif peut suffire. On parle alors de description informelle. Considérons par exemple une «description informelle» (textuelle) de l opération «agrandir». PRECONDITIONS [agrandir(delta)] --> On peut augmenter la largeur et la hauteur d un rectangle d une valeur «delta» (delta pouvant être négatif), à condition que la largeur et la hauteur du rectangle qui en résulte restent positives ou nulles. Si «delta» est négatif, cela entraînera une diminution du rectangle. POSTCONDITIONS [agrandir(delta)] --> Après son agrandissement, la largeur et la hauteur du rectangle sont égales à leur ancienne valeur, augmentée de la valeur delta, passée en paramètre. Les coordonnées du point supérieur gauche du rectangle sont inchangées. On peut vérifier en analysant ces préconditions et postconditions que ces dernières sont bien exprimées en fonction: 1. de l état de l objet (sa valeur) avant et après l opération; 2. de la valeur des paramètres Description formelle de la sémantique Une description textuelle est parfois ambiguë, peu précise et souvent très lourde. Dans la mesure du possible, on préfère décrire la sémantique au moyen «d expressions mathématiques». C est ce que l on appelle une «description formelle». La notion «d expression» Une «expression» est une formule mathématique qui peut être «évaluée», c est-à-dire

34 POO avec Java Objets et types abstraits qui «retourne» un résultat si on demande son exécution. Voici quelques exemples d expressions, où «r» est un objet de type «Rectangle_I». On supposera que la largeur et la hauteur du rectangle valent respectivement «5» et «10» et que son point supérieur gauche est positionné en <3, 4>. Tableau 9: Exemples d expressions Expression Résultat de l expression 1/ r.getlargeur() 5 getlargeur() est une fonction. Le résultat de l expression correspond à la valeur retournée par la fonction. 2/ r.getx() 3 3/ r.gety() 4 4/ r.agrandir(2) «r» (l objet qui subit l opération). En effet, agrandir(..) est une procédure. L expression retourne alors l objet même qui reçoit le message a. 5/ r.getlargeur() 7 (le rectangle a été agrandi) 6/ r.agrandir(4).getlargeur() 11 Enchaînement de messages de gauche à droite. Cette expression retourne la valeur de la largeur du rectangle après un nouvel agrandissement b. 7/ new Rectangle() Un nouvel objet de type «Rectangle». Valeur du point supérieur gauche: <0,0>, largeur: <0>, hauteur: <0> 8/ r = new Rectangle() «r» (un nouveau rectangle de valeur <0,0,0,0>) Une affectation («=») est une expression qui retourne l entité qui a été affectée.

35 POO avec Java Objets et types abstraits Tableau 9: Exemples d expressions Expression Résultat de l expression 9/ (r = new Rectangle()).getLargeur() 0 (largeur de «r», un nouveau rectangle) a. Ceci serait valable également en Smalltalk, mais pas en Java: une procédure ne retourne rien en Java!! b. Ceci serait valable aussi en Smalltalk, mais pas en Java: «c.agrandir ()» ne retourne rien («agrandir» est une procédure), et on ne peut donc pas enchaîner avec le message «getlargeur()» Une remarque importante!! Les expressions écrites ci-dessus ne sont valables que dans le contexte de la sémantique des opérations. Ecrites en Java, les expressions no 4 et no 6 ne seraient pas valables puisqu une procédure Java ne retourne rien. Ecrite en Java, l expression no 4 n en est pas une! En effet, «agrandir» est une procédure et par conséquent, «c.agrandir(2)» ne retourne absolument rien. En Java, toujours, l expression no 6 n est pas correcte non plus, et pour les mêmes raisons. Comme «c.agrandir(4)» ne retourne rien, on ne peut pas envoyer le message «getlargeur()» à ce «rien». Exprimer la sémantique des opérations Revenons maintenant aux opérations. Pour ce qui nous concerne, nous décrirons la sémantique au moyen d axiomes, des expressions logiques qui doivent toujours être «vraies». Pour exprimer la sémantique d une opération, les préconditions utiliseront le mot-clé «this», qui désigne l objet qui doit subir l opération. L état de cet objet est celui qu il possède avant de subir l opération. Pour plus de clarté, nous utiliserons dans le cadre des postconditions le mot-clé «old», qui désignera l objet dans son état avant l opération, et le mot-clé «new» qui désignera l objet après avoir subit l opération. Reprenons par exemple l opération «agrandir (delta)». Voici une description formelle de sa sémantique: PRECONDITIONS [agrandir(delta)] this.getlargeur() + delta >= 0 this.gethauteur() + delta >= 0

36 POO avec Java Objets et types abstraits POSTCONDITIONS [agrandir(delta)] new.getlargeur() == old.getlargeur() + delta new.gethauteur() == old.gethauteur() + delta new.getx() == old.getx() new.gety() == old.gety() Considérons maintenant l exemple de l opération «new Rectangle()». PRECONDITIONS [new Rectangle()] -- (pas de précondition) POSTCONDITIONS [new Rectangle()] new.getlargeur() == 0 new.gethauteur() == 0 new.getx() == 0 new.gety() == La programmation «par contrat» Bertrand Meyer, informaticien de renom et concepteur du langage Eiffel, a développé voici quelques années le concept de programmation par contrat. Ce concept a pour but de simplifier le raisonnement du programmeur qui doit concevoir une nouvelle opération, et également le raisonnement de celui qui, au contraire, doit utiliser une opération écrite par un autre, ou éventuellement par lui-même. L idée est relativement simple. Une opération est un «service». Demander l exécution d une opération peut être imaginée comme la signature d un contrat entre une entreprise qui offre ce service et nous mêmes qui en sommes le client. Postconditions L entreprise s engage à remplir son contrat et à accomplir le service demandé. Préconditions En revanche, le client doit assurer que les conditions préalables sont respectées. Donc,.. Avant d appeler une opération, le programmeur-client doit s assurer que les préconditions sont respectées. Il lèvera une exception si ça n est pas le cas. Notons que dans certains styles de programmation, la levée d exception est plutôt opérée en début d opération par le programmeur-entreprise lui-même (qui contrôle si les préconditions sont respectées) Pour s assurer que le contrat est rempli, le programmeur-entreprise doit s assurer que les postconditions sont respectées (sinon, le programmeur-entreprise lèvera une exception en fin d opération). Le programmeur-entreprise n a pas à prévoir de comportement par défaut si jamais les préconditions n ont pas été respectées. L opération doit se concentrer sur une seule chose: accomplir sa tâche correctement.