De plus, un des gros avantages de l’approche par contrats est qu’il permet de palier \u00e0 certaines probl\u00e9matiques d’autres langages ont au niveau du principe objets. Par exemple, les langages bas\u00e9s sur C++ (incluant Java et C#) prot\u00e8gent l’int\u00e9grit\u00e9 interne des classes en utilisant la port\u00e9e priv\u00e9e des m\u00e9thodes et des attributs. Comme nous l’avons vu dans une th\u00e9orie pr\u00e9c\u00e9dente, la port\u00e9e priv\u00e9e va \u00e0 l’encontre du principe objet puisque les enfants des classes n’ont pas acc\u00e8s \u00e0 l’enti\u00e8ret\u00e9 des m\u00e9thodes et attributs que ces classes parentes ont acc\u00e8s. Les contrats permettent une robustesse des classes similaires \u00e0 la port\u00e9e priv\u00e9e (en fait meilleur en g\u00e9n\u00e9ral), mais tout en respectant parfaitement le principe objets, puisque les contrats des parents s’appliquent toujours \u00e0 l’enti\u00e8ret\u00e9 des enfants.<\/p>\n
Il y a plusieurs sortes de contrats. Ceux qui nous int\u00e9resseront dans ce cours sont les trois (3) types de contrats suivants: les pr\u00e9conditions, les postconditions et les invariants.<\/p>\n
Une pr\u00e9condition est un contrat ajout\u00e9 \u00e0 une routine qui permet de valider l’\u00e9tat de la classe avant l’ex\u00e9cution de la routine ou de valider les arguments de la cette derni\u00e8re afin de s’assurer qu’elle s’ex\u00e9cute correctement. On note les pr\u00e9conditions dans la clause \u00ab\u00a0require\u00a0\u00bb d’une m\u00e9thode. Voici un exemple utilisant des pr\u00e9conditions.<\/p>\n
\n
make<\/span>(<\/span>a_heure<\/span>,<\/span> a_minute<\/span>,<\/span> a_seconde<\/span>:<\/span>NATURAL_8<\/span>)<\/span>\r\n\t\t-- Initialisation de `Current' utilisant `a_heure' comme `heure',<\/span>\r\n\t\t-- `a_minute' comme `minute' et `a_seconde' comme `seconde'<\/span>\r\n\trequire<\/span>\r\n\t\tHeure_Valide<\/span>:<\/span> a_heure<\/span> <<\/span> 24<\/span>\r\n\t\tMinute_Valide<\/span>:<\/span> a_minute<\/span> <<\/span> 60<\/span>\r\n\t\tSeconde_Valide<\/span>:<\/span> a_seconde<\/span> <<\/span> 60<\/span>\r\n\tdo<\/span>\r\n\t\tset_heure<\/span>(<\/span>a_heure<\/span>)<\/span>\r\n\t\tset_minute<\/span>(<\/span>a_minute<\/span>)<\/span>\r\n\t\tset_seconde<\/span>(<\/span>a_seconde<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\nPrendre note que pour cet exemple, je n’ai pas mis les postconditions qui devraient normalement \u00eatre faites dans cette m\u00e9thode.<\/p>\n
On voit que cette m\u00e9thode n\u00e9cessite que le client de la classe envoie un argument a_heure<\/code> inf\u00e9rieur \u00e0 24 ainsi que des arguments a_minute<\/code> et a_seconde<\/code> inf\u00e9rieur \u00e0 60 (puisque ce sont des NATURAL<\/code>, les clients ne peuvent pas envoyer de sombre n\u00e9gatif en argument).<\/p>\nEn plus de v\u00e9rifier que les informations sont correctes lors du \u00ab\u00a0d\u00e9buguage\u00a0\u00bb du syst\u00e8me, les pr\u00e9conditions permettent aux clients de la classe de savoir ce qui devrait \u00eatre test\u00e9 afin d’utiliser la m\u00e9thode. Par exemple, dans l’exemple pr\u00e9c\u00e9dent, le client de la classe devrait s’assurer que les pr\u00e9conditions sont respect\u00e9s en lan\u00e7ant la classe:<\/p>\n
\n
\t\tif<\/span> l_heure<\/span> <<\/span> 24<\/span> and<\/span> l_minute<\/span> <<\/span> 60<\/span> and<\/span> l_seconde<\/span> <<\/span> 60<\/span> then<\/span>\r\n\t\t\tcreate<\/span> l_temps<\/span>.<\/span>make<\/span> (<\/span>l_heure<\/span>,<\/span> l_minute<\/span>,<\/span> l_seconde<\/span>)<\/span>\r\n\t\telse<\/span>\r\n\t\t\tprint<\/span>(<\/span>\"Une valeur n'est pas valide.%N\"<\/span>)<\/span>\r\n\t\tend<\/span>\r\n<\/pre>\n<\/div>\nNote sur l’h\u00e9ritage<\/h3>\n
Il est \u00e0 noter qu’il est possible de mettre une pr\u00e9condition \u00e0 une m\u00e9thode qui est red\u00e9finie. Par contre, au lieu d’utiliser la clause \u00ab\u00a0require\u00a0\u00bb, il faut utiliser la clause \u00ab\u00a0require else\u00a0\u00bb. Il est \u00e9galement \u00e0 noter que la m\u00e9thode pourra \u00eatre ex\u00e9cut\u00e9e \u00e0 l’instant ou les pr\u00e9conditions d’une des classes (enfants ou parents) sont valides. En d’autres mots, c’est un \u00ab\u00a0OU\u00a0\u00bb qui est fait entre les pr\u00e9conditions des diff\u00e9rentes classes de l’h\u00e9ritage. Par exemple, supposons que je voulais faire une nouvelle classe qui ne limite pas l’heure \u00e0 24 heures. Voici comment la classe pourrait \u00eatre \u00e9crite:<\/p>\n
\n
class<\/span>\r\n\tTEMPS_SANS_FIN<\/span>\r\n\r\ninherit<\/span>\r\n\tTEMPS<\/span>\r\n\t\tredefine<\/span>\r\n\t\t\tmake<\/span>,<\/span> set_heure<\/span>\r\n\t\tend<\/span>\r\n\r\ncreate<\/span>\r\n\tmake<\/span>\r\n\r\nfeature<\/span> {<\/span>NONE<\/span>}<\/span> -- Initialisation<\/span>\r\n\r\n\tmake<\/span>(<\/span>a_heure<\/span>,<\/span> a_minute<\/span>,<\/span> a_seconde<\/span>:<\/span>NATURAL_8<\/span>)<\/span>\r\n\t\t\t-- <Precursor><\/span>\r\n\t\trequire<\/span> else<\/span>\r\n\t\t\tMinute_Valide<\/span>:<\/span> a_minute<\/span> <<\/span> 60<\/span>\r\n\t\t\tSeconde_Valide<\/span>:<\/span> a_seconde<\/span> <<\/span> 60<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tPrecursor<\/span>(<\/span>a_heure<\/span>,<\/span> a_minute<\/span>,<\/span> a_seconde<\/span>)<\/span>\r\n\t\tend<\/span>\r\n\r\nfeature<\/span> -- Access<\/span>\r\n\r\n\tset_heure<\/span>(<\/span>a_heure<\/span>:<\/span>NATURAL_8<\/span>)<\/span>\r\n\t\t\t-- <Precursor><\/span>\r\n\t\trequire<\/span> else<\/span>\r\n\t\t\tTrue<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tPrecursor<\/span>(<\/span>a_heure<\/span>)<\/span>\r\n\t\tend<\/span>\r\n\r\nend<\/span>\r\n<\/pre>\n<\/div>\nLe \u00ab\u00a0require else True\u00a0\u00bb de la m\u00e9thode set_heure<\/code> permet en fait d’enlever compl\u00e8tement les pr\u00e9conditions de tous les parents.<\/p>\nLes postconditions<\/h2>\n
Les postconditions d’une m\u00e9thode permettent de s’assurer que la m\u00e9thode en question a effectu\u00e9 son travail correctement. Normalement, dans une m\u00e9thode correctement \u00e9crite, si les pr\u00e9conditions de la m\u00e9thode passent sans erreur, la m\u00e9thode devrait se terminer correctement et les postconditions devraient \u00eatre vraies, peu importe les arguments envoy\u00e9s et l’\u00e9tat d’origine de l’objet. Les postconditions sont plac\u00e9es dans la clause \u00ab\u00a0ensure\u00a0\u00bb de la m\u00e9thode. Voici la m\u00e9thode pr\u00e9c\u00e9dente avec les postconditions:<\/p>\n
\n
make<\/span>(<\/span>a_heure<\/span>,<\/span> a_minute<\/span>,<\/span> a_seconde<\/span>:<\/span>NATURAL_8<\/span>)<\/span>\r\n\t\t-- Initialisation de `Current' utilisant `a_heure' comme `heure',<\/span>\r\n\t\t-- `a_minute' comme `minute' et `a_seconde' comme `seconde'<\/span>\r\n\trequire<\/span>\r\n\t\tHeure_Valide<\/span>:<\/span> a_heure<\/span> <<\/span> 24<\/span>\r\n\t\tMinute_Valide<\/span>:<\/span> a_minute<\/span> <<\/span> 60<\/span>\r\n\t\tSeconde_Valide<\/span>:<\/span> a_seconde<\/span> <<\/span> 60<\/span>\r\n\tdo<\/span>\r\n\t\tset_heure<\/span>(<\/span>a_heure<\/span>)<\/span>\r\n\t\tset_minute<\/span>(<\/span>a_minute<\/span>)<\/span>\r\n\t\tset_seconde<\/span>(<\/span>a_seconde<\/span>)<\/span>\r\n\tensure<\/span>\r\n\t\tHeure_Assigne<\/span>:<\/span> heure<\/span> =<\/span> a_heure<\/span>\r\n\t\tMinute_Assigne<\/span>:<\/span> minute<\/span> =<\/span> a_minute<\/span>\r\n\t\tseconde_Assigne<\/span>:<\/span> seconde<\/span> =<\/span> a_seconde<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\nOn voit ici que la m\u00e9thode garantit que les trois (3) attributs (heure, minute et seconde) seront correctement assign\u00e9s en fonction des valeurs des trois (3) arguments (a_heure, a_minute et a_seconde).<\/p>\n
Du c\u00f4t\u00e9 du client, il est int\u00e9ressant de comprendre que la postcondition d’une m\u00e9thode peut servir de validation pour les pr\u00e9conditions d’une autre m\u00e9thode. Par exemple, dans l’exemple de la classe TEMPS<\/code> vu plus haut, puisque les postconditions garantissent que les attributs (heure, minute et seconde) sont corrects, il n’est pas n\u00e9cessaire de valider les valeurs (avec un if<\/code> comme dans l’exemple dans la section sur les pr\u00e9conditions). Par exemple, on peut simplement faire le code suivant:<\/p>\n\n
l_temps1<\/span>.<\/span>set_heure<\/span> (<\/span>l_temps2<\/span>.<\/span>heure<\/span>)<\/span>\r\n<\/pre>\n<\/div>\nen \u00e9tant persuad\u00e9 que la pr\u00e9condition de set_heure<\/code> (que l’heure est inf\u00e9rieur \u00e0 24) est valide. Lorsque les pr\u00e9conditions et les postconditions sont bien fait, cet effet \u00ab\u00a0domino\u00a0\u00bb (les postconditions valide les pr\u00e9conditions) arrivent beaucoup.<\/p>\nOn peut utiliser le mot cl\u00e9 old<\/code> pour aller chercher la valeur telle qu’elle \u00e9tait avant l’utilisation de la m\u00e9thode. Par exemple:<\/p>\n\n
ajouter<\/span>(<\/span>a_element<\/span>:<\/span>like<\/span> element<\/span>)<\/span>\r\n\tdeferred<\/span>\r\n\tensure<\/span>\r\n\t\tElement_Ajoute<\/span>:<\/span> nombre_elements<\/span>