{"id":60,"date":"2021-05-29T13:51:13","date_gmt":"2021-05-29T13:51:13","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=60"},"modified":"2022-02-09T16:19:26","modified_gmt":"2022-02-09T16:19:26","slug":"la-programmation-orientee-objet","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/la-programmation-orientee-objet\/","title":{"rendered":"La programmation orient\u00e9e objet"},"content":{"rendered":"<h2>Un bref historique<\/h2>\n<ul>\n<li style=\"list-style-type: none;\">\n<ul>\n<li>Simula\n<ul>\n<li>Cr\u00e9\u00e9 en 1962 par Ole-Johan Dahl et Kristen Nygaard<\/li>\n<li>Langage de simulation<\/li>\n<li>Bas\u00e9 sur Algol60, un langage proc\u00e9dural utilis\u00e9 dans les ann\u00e9es 1960<\/li>\n<li>L&rsquo;invention du concept objet par accident<\/li>\n<li>L&rsquo;objectif du langage \u00e9tait de simuler des objets de la vie r\u00e9elle.<\/li>\n<li>M\u00eame s&rsquo;il s&rsquo;agit du premier langage-objet, son impl\u00e9mentation objet est chaotique et mal structur\u00e9e.<\/li>\n<\/ul>\n<\/li>\n<li>Smalltalk\n<ul>\n<li>Cr\u00e9\u00e9 en 1972 par Alan Kay, Dan Ingals, Ted Kaehler, Adele Goldberg<\/li>\n<li>L&rsquo;objectif du langage est la transmission de message entre instances d&rsquo;objet.<\/li>\n<li>Bas\u00e9 sur Simula<\/li>\n<li>Langage par prototype.<\/li>\n<li>Alan Kay est souvent consid\u00e9r\u00e9 comme un des p\u00e8res de la programmation orient\u00e9e objet 2.<\/li>\n<\/ul>\n<\/li>\n<li>C++\n<ul>\n<li>Cr\u00e9\u00e9 en 1983 par Bjarne Stroustrup<\/li>\n<li>\u00c9volution orient\u00e9e objet du langage C<\/li>\n<li>Structure objet puissante, mais mal structur\u00e9e.\n<ul>\n<li>Certains programmeurs C++ se r\u00e9fugient dans les \u00ab\u00a0template\u00a0\u00bb C++ pour \u00e9viter les probl\u00e8mes que peut poser la structure objet C++.<\/li>\n<li>Certains programmeurs \u00e9vitent d&rsquo;utiliser certains concepts objet C++ (par exemple, l&rsquo;h\u00e9ritage multiple) afin d&rsquo;\u00e9viter les probl\u00e8mes que peut poser la structure objet C++<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<li>Eiffel\n<ul>\n<li>Cr\u00e9er en 1986 par Bertrand Meyer<\/li>\n<li>les langages orient\u00e9s objet de l&rsquo;\u00e9poque \u00e9taient souvent mal structur\u00e9s et malgr\u00e9 que beaucoup de bonnes id\u00e9es ressortaient, le domaine \u00e9tait pour le moins, chaotique.<\/li>\n<li>Bertrand Meyer, un chercheur en d\u00e9veloppement logiciel, \u00e9crivit un livre sur le d\u00e9veloppement de langage orient\u00e9 objet:\n<ul>\n<li>Object-Oriented Software Construction<\/li>\n<\/ul>\n<\/li>\n<li>Aucun langage \u00e0 l&rsquo;\u00e9poque ne permettait de g\u00e9rer tous les concepts objets pr\u00e9sent\u00e9s dans le livre;<\/li>\n<li>Bretrand Meyer a donc invent\u00e9 un langage th\u00e9orique (\u00e0 l&rsquo;\u00e9poque) qui lui permettrait de donner les d\u00e9monstration et exemple n\u00e9cessaire dans son livre.<\/li>\n<li>Bertrand Meyer est \u00e9galement consid\u00e9r\u00e9 comme un des p\u00e8res de la programmation orient\u00e9e objet.<\/li>\n<\/ul>\n<\/li>\n<li>Java:\n<ul>\n<li>Cr\u00e9\u00e9 en 1996 par Sun Microsystem.<\/li>\n<li>L&rsquo;objectif \u00e9tait de cr\u00e9er des programmes orient\u00e9s objet pour le Web<\/li>\n<li>Contrairement aux langages orient\u00e9s objet de l&rsquo;\u00e9poque (C++, Ada, Pascal, etc.), Java obligeait l&rsquo;utilisation de l&rsquo;orient\u00e9e objet dans la cr\u00e9ation de code.<\/li>\n<li>Malgr\u00e9 qu&rsquo;il n&rsquo;a apport\u00e9 aucune \u00e9volution aux m\u00e9caniques objets, java a grandement particip\u00e9 \u00e0 l&rsquo;int\u00e9r\u00eat des d\u00e9veloppeurs pour les technologies objet.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<h2>Un objet<\/h2>\n<p>Un <strong>objet<\/strong> est une repr\u00e9sentation abstraite d&rsquo;une <strong>instance m\u00e9moire<\/strong> permettant de regrouper des <strong>informations<\/strong> reli\u00e9es entre elles par des liens logiques et des <strong>m\u00e9canismes<\/strong> permettant la manipulation de ces informations.<\/p>\n<h4>Comparaison avec la programmation proc\u00e9durale<\/h4>\n<p>Comme on peut le constater dans la d\u00e9finition, la programmation orient\u00e9e objet met de l&rsquo;avant les informations avant les m\u00e9canismes. Inversement, la programmation proc\u00e9durale met au premier plan les m\u00e9canismes (les routines) et les informations interviennent d&rsquo;une certaine mani\u00e8re en support \u00e0 ces m\u00e9canisme. Il s&rsquo;agit d&rsquo;un changement de paradigme majeur.<\/p>\n<h3>Les classes<\/h3>\n<p>Une <strong>classe<\/strong> est une d\u00e9finition des caract\u00e9ristiques communes d&rsquo;un ensemble d&rsquo;objets. Elle contient, entre autres, l&rsquo;ensemble des attributs et des d\u00e9clarations de m\u00e9thodes que ces objets ont en commun.<\/p>\n<p>Voici la syntaxe d&rsquo;une classe en Java:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"kd\">public<\/span> <span class=\"kd\">class<\/span> <span class=\"nc\">Personne<\/span> <span class=\"p\">{<\/span>\r\n    <span class=\"p\">...<\/span>\r\n<span class=\"p\">}<\/span>\r\n<\/pre>\n<\/div>\n<p>Cet exemple repr\u00e9sente une classe publique. Une classe publique doit \u00eatre plac\u00e9e dans son propre fichier et le nom du fichier doit \u00eatre le m\u00eame que le nom de la classe, sans prendre en compte l&rsquo;extension \u00ab\u00a0.java\u00a0\u00bb. Par exemple, dans l&rsquo;exemple pr\u00e9c\u00e9dent, le fichier qui contient cette classe devrait s&rsquo;appeler \u00ab\u00a0Personne.java\u00a0\u00bb.<\/p>\n<h2>Instanciation<\/h2>\n<p>On dit qu&rsquo;un objet est une <strong>instance<\/strong> de classe. Il est important de bien saisir la nuance entre une classe et un objet. En comparaison, vous pouvez voir la classe comme \u00e9tant une recette de cuisine et l&rsquo;objet comme \u00e9tant le plat cr\u00e9\u00e9 gr\u00e2ce \u00e0 cette recette. Par exemple, si notre classe est une recette de g\u00e2teau, chaque g\u00e2teau sera une instance de cette classe. On peut voir qu&rsquo;avec la m\u00eame recette de g\u00e2teau, il est possible de faire une grande quantit\u00e9 de g\u00e2teau diff\u00e9rent (couleur, d\u00e9coration, etc.) De la m\u00eame mani\u00e8re, une classe peut \u00eatre utilis\u00e9e afin de g\u00e9n\u00e9rer plusieurs objets diff\u00e9rents (avec des valeurs diff\u00e9rentes). Par exemple, une classe \u00ab\u00a0Personne\u00a0\u00bb contenant un \u00ab\u00a0nom\u00a0\u00bb et un \u00ab\u00a0prenom\u00a0\u00bb pourrait \u00eatre utilis\u00e9 pour cr\u00e9er les trois objets diff\u00e9rents: \u00ab\u00a0Louis Marchand\u00a0\u00bb, \u00ab\u00a0Elon Musk\u00a0\u00bb et \u00ab\u00a0Chuck Norris\u00a0\u00bb.<\/p>\n<p>En java, on utilise le mot cl\u00e9 \u00ab\u00a0new\u00a0\u00bb pour instancier un objet:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"n\">Personne<\/span> <span class=\"n\">lPersonne<\/span> <span class=\"o\">=<\/span> <span class=\"k\">new<\/span> <span class=\"n\">Personne<\/span><span class=\"p\">();<\/span>\r\n<\/pre>\n<\/div>\n<p>Dans cet exemple, nous instancions un objet bas\u00e9 sur la classe \u00ab\u00a0Personne\u00a0\u00bb et nous assignons cet objet \u00e0 la variable \u00ab\u00a0lPersonne\u00a0\u00bb.<\/p>\n<h2>Les attributs<\/h2>\n<p>On appelle <strong>attribut<\/strong> d&rsquo;un objet une information qui sp\u00e9cifie une caract\u00e9ristique d&rsquo;un objet. L&rsquo;ensemble des attributs d&rsquo;un objet permet de caract\u00e9riser pr\u00e9cis\u00e9ment l&rsquo;<strong>\u00e9tat d&rsquo;un objet<\/strong>.<\/p>\n<p>En java, les attributs sont d\u00e9clar\u00e9s de la m\u00eame mani\u00e8re qu&rsquo;une variable, mais \u00e0 l&rsquo;ext\u00e9rieur d&rsquo;une routine. Par exemple:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"kd\">public<\/span> <span class=\"kd\">class<\/span> <span class=\"nc\">Personne<\/span> <span class=\"p\">{<\/span>\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">prenom<\/span><span class=\"p\">;<\/span>\r\n<span class=\"p\">}<\/span>\r\n<\/pre>\n<\/div>\n<p>Dans cet exemple, la classe \u00ab\u00a0Personne\u00a0\u00bb a 2 attributs: \u00ab\u00a0nom\u00a0\u00bb et \u00ab\u00a0prenom\u00a0\u00bb. Pour l&rsquo;instant, nous allons tous mettre publique. Mais dans une future th\u00e9orie, nous allons voir qu&rsquo;il ne faut pas d\u00e9clar\u00e9 un attribut publique. Nous utilisons des attribut publique ici afin de pouvoir tester nos classes de base, sans avoir \u00e0 cr\u00e9er des structures plus complexe.<\/p>\n<h2>Les m\u00e9thodes<\/h2>\n<p>On appelle <strong>m\u00e9thode<\/strong> d&rsquo;un objet une routine s&rsquo;appliquant \u00e0 cet objet en particulier.<\/p>\n<p>En java, puisqu&rsquo;une m\u00e9thode est une routine, les m\u00e9thodes sont d\u00e9clar\u00e9es de la m\u00eame mani\u00e8re que les routines. Par exemple:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"kd\">public<\/span> <span class=\"kd\">class<\/span> <span class=\"nc\">Personne<\/span> <span class=\"p\">{<\/span>\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">prenom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"nf\">nomComplet<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"k\">return<\/span> <span class=\"n\">prenom<\/span> <span class=\"o\">+<\/span> <span class=\"s\">\" \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"kt\">void<\/span> <span class=\"nf\">bonjour<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"n\">System<\/span><span class=\"p\">.<\/span><span class=\"na\">out<\/span><span class=\"p\">.<\/span><span class=\"na\">println<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Bonjour \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nomComplet<\/span><span class=\"p\">());<\/span>\r\n    <span class=\"p\">}<\/span>\r\n<span class=\"p\">}<\/span>\r\n<\/pre>\n<\/div>\n<p>On voit que ma classe \u00ab\u00a0Personne\u00a0\u00bb a deux (2) m\u00e9thodes: \u00ab\u00a0nomComplet\u00a0\u00bb qui est une fonction et \u00ab\u00a0bonjour\u00a0\u00bb qui est une proc\u00e9dure.<\/p>\n<h2>Le type d&rsquo;un objet<\/h2>\n<p>Le type d&rsquo;un objet repr\u00e9sente la classe (ou le type primitif) utilis\u00e9e dans la d\u00e9claration de la variable contenant cet objet. Par exemple, dans le code suivant:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"n\">Personne<\/span> <span class=\"n\">lPersonne<\/span><span class=\"p\">;<\/span>\r\n<\/pre>\n<\/div>\n<p>L&rsquo;objet (et la variable) lPersonne est de type Personne.<\/p>\n<h2>Liens client\/fournisseur<\/h2>\n<h3>Les clients d&rsquo;une classe<\/h3>\n<p>On dit qu&rsquo;une classe A est <strong>client<\/strong> d&rsquo;une classe B si un attribut ou une fonction de la classe A retourne un objet ou un ensemble d&rsquo;objets de type B.<\/p>\n<p>Il est \u00e0 noter que, par simplicit\u00e9, on \u00e9largit parfois cette d\u00e9finition afin d&rsquo;y inclure tous les variables locales et arguments de m\u00e9thodes.<\/p>\n<p>Par exemple, dans le code java de \u00ab\u00a0Personne\u00a0\u00bb pr\u00e9sent\u00e9 plus haut, la classe \u00ab\u00a0Personne\u00a0\u00bb est client de la classe \u00ab\u00a0String\u00a0\u00bb puisque deux (2) attributs sont de type \u00ab\u00a0String\u00a0\u00bb et une m\u00e9thode retourne un objet de type \u00ab\u00a0String\u00a0\u00bb.<\/p>\n<h3>Les fournisseurs d&rsquo;une classe<\/h3>\n<p>On dit qu&rsquo;une classe A est <strong>fournisseur<\/strong> d&rsquo;une classe B si un attribut ou une fonction de la classe B retourne un objet ou un ensemble d&rsquo;objets de type A. En d&rsquo;autres mots, un lien fournisseur est l&rsquo;inverse d&rsquo;un lien client.<\/p>\n<p>Donc, dans le code java de \u00ab\u00a0Personne\u00a0\u00bb pr\u00e9sent\u00e9 plus haut, la classe \u00ab\u00a0String\u00a0\u00bb est fournisseur de la classe \u00ab\u00a0Personne\u00a0\u00bb.<\/p>\n<h2>Les constructeurs<\/h2>\n<p>Un constructeur est une proc\u00e9dure sp\u00e9ciale de la classe. Son objectif est d&rsquo;initialiser l&rsquo;\u00e9tat de l&rsquo;objet. En g\u00e9n\u00e9ral, \u00e7a signifie initialiser les attributs de l&rsquo;objet. Cette proc\u00e9dure est appel\u00e9e lors de l&rsquo;instanciation de l&rsquo;objet (en java, lorsqu&rsquo;un \u00ab\u00a0new\u00a0\u00bb est utilis\u00e9).<\/p>\n<p>Il y a une r\u00e8gle d&rsquo;or en programmation orient\u00e9e objet disant que les constructeurs de chaque classe ont comme responsabilit\u00e9 d&rsquo;initialiser tous les attributs de cette classe. En d&rsquo;autres mots, s&rsquo;il y a des attributs dans une classes, il devrait normalement y avoir au moins un constructeur qui initialise ces attributs. Un attribut ne devrait pas rester non initialis\u00e9 apr\u00e8s l&rsquo;instanciation d&rsquo;un objet. Il est par contre possible d&rsquo;initialiser un attribut avec une valeur NULL (une variable est dit NULL lorsque celle-ci ne contient aucun objet).<\/p>\n<p>En java, le constructeur est nomm\u00e9 avec le m\u00eame nom de la classe et n&rsquo;a aucun type de retour (m\u00eame pas void). Il est possible d&rsquo;avoir plusieurs constructeurs, pourvu que la signature de chaque constructeur soit diff\u00e9rente. En d&rsquo;autres mots, chaque constructeur doit avoir des arguments de types diff\u00e9rents.<\/p>\n<p>Par exemple:<\/p>\n<div class=\"highlight\">\n<pre><span><\/span><span class=\"kd\">public<\/span> <span class=\"kd\">class<\/span> <span class=\"nc\">Personne<\/span> <span class=\"p\">{<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">prenom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(<\/span><span class=\"n\">String<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">,<\/span> <span class=\"n\">String<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"nf\">nomComplet<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"k\">return<\/span> <span class=\"n\">prenom<\/span> <span class=\"o\">+<\/span> <span class=\"s\">\" \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"kt\">void<\/span> <span class=\"nf\">bonjour<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"n\">System<\/span><span class=\"p\">.<\/span><span class=\"na\">out<\/span><span class=\"p\">.<\/span><span class=\"na\">println<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Bonjour \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nomComplet<\/span><span class=\"p\">());<\/span>\r\n    <span class=\"p\">}<\/span>\r\n<span class=\"p\">}<\/span>\r\n<\/pre>\n<\/div>\n<p>On voit que dans cette classe, nous avons 2 constructeurs. Un constructeur ne prenant aucun argument et un constructeur ayant deux (2) arguments (\u00ab\u00a0aNom\u00a0\u00bb et \u00ab\u00a0aPrenom\u00a0\u00bb).<\/p>\n<p>Pour utiliser les constructeurs diff\u00e9rents, il faut envoyer le bon nombre et bons types d&rsquo;arguments lors de l&rsquo;ex\u00e9cution du \u00ab\u00a0new\u00a0\u00bb. Par exemple, pour utiliser le constructeur sans argument, nous utilisons:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"n\">Personne<\/span> <span class=\"n\">lPersonne<\/span> <span class=\"o\">=<\/span> <span class=\"k\">new<\/span> <span class=\"n\">Personne<\/span><span class=\"p\">();<\/span>\r\n<\/pre>\n<\/div>\n<p>et pour utiliser le constructeur avec 2 arguments, nous utilisons:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"n\">Personne<\/span> <span class=\"n\">lPersonne<\/span> <span class=\"o\">=<\/span> <span class=\"k\">new<\/span> <span class=\"n\">Personne<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Marchand\"<\/span><span class=\"p\">,<\/span> <span class=\"s\">\"Louis\"<\/span><span class=\"p\">);<\/span>\r\n<\/pre>\n<\/div>\n<h4>Limitation<\/h4>\n<p>Il est \u00e0 noter qu&rsquo;il existe certaines limitations avec le syst\u00e8me de constructeurs de Java. Une limitation importante, c&rsquo;est qu&rsquo;il est impossible d&rsquo;avoir plusieurs constructeurs diff\u00e9rents avec le m\u00eame nombre d&rsquo;arguments de m\u00eame type dans le m\u00eame ordre. Par exemple, ce code ne fonctionnera pas:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"kd\">public<\/span> <span class=\"kd\">class<\/span> <span class=\"nc\">Personne<\/span> <span class=\"p\">{<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">prenom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(<\/span><span class=\"n\">String<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(<\/span><span class=\"n\">String<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(<\/span><span class=\"n\">String<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">,<\/span> <span class=\"n\">String<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"nf\">nomComplet<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"k\">return<\/span> <span class=\"n\">prenom<\/span> <span class=\"o\">+<\/span> <span class=\"s\">\" \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"kt\">void<\/span> <span class=\"nf\">bonjour<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"n\">System<\/span><span class=\"p\">.<\/span><span class=\"na\">out<\/span><span class=\"p\">.<\/span><span class=\"na\">println<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Bonjour \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nomComplet<\/span><span class=\"p\">());<\/span>\r\n    <span class=\"p\">}<\/span>\r\n<span class=\"p\">}<\/span>\r\n<\/pre>\n<\/div>\n<p>En effet, puisque la classe a deux (2) constructeurs avec la signature: \u00ab\u00a0public Personne(String)\u00a0\u00bb, il n&rsquo;y a aucune mani\u00e8re pour le compilateur Java de savoir quel constructeur utiliser dans le code:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"n\">Personne<\/span> <span class=\"n\">lPersonne<\/span> <span class=\"o\">=<\/span> <span class=\"k\">new<\/span> <span class=\"n\">Personne<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Martin\"<\/span><span class=\"p\">);<\/span>\r\n<\/pre>\n<\/div>\n<h4>Appeler un constructeur \u00e0 partir d&rsquo;un autre constructeur<\/h4>\n<p>Tout comme il est possible d&rsquo;appeler n&rsquo;importe quelle m\u00e9thode de la classe \u00e0 partir d&rsquo;un constructeur, il est \u00e9galement possible d&rsquo;appeler un autre constructeur. Pour appeler un constructeur \u00e0 partir d&rsquo;un autre constructeur, on utilise la syntaxe: \u00ab\u00a0this(&#8230;)\u00a0\u00bb (ou les trois points repr\u00e9sentent les arguments \u00e0 envoyer au constructeur).<\/p>\n<p>Par exemple, le code de \u00ab\u00a0Personne\u00a0\u00bb ci-haut (avec 2 constructeurs) est \u00e9quivalent \u00e0 ce code:<\/p>\n<div class=\"highlight\">\n<pre><span class=\"kd\">public<\/span> <span class=\"kd\">class<\/span> <span class=\"nc\">Personne<\/span> <span class=\"p\">{<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"n\">prenom<\/span><span class=\"p\">;<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"k\">this<\/span><span class=\"p\">(<\/span><span class=\"s\">\"\"<\/span><span class=\"p\">,<\/span> <span class=\"s\">\"\"<\/span><span class=\"p\">);<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"nf\">Personne<\/span><span class=\"p\">(<\/span><span class=\"n\">String<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">,<\/span> <span class=\"n\">String<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">){<\/span>\r\n        <span class=\"n\">nom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aNom<\/span><span class=\"p\">;<\/span>\r\n        <span class=\"n\">prenom<\/span> <span class=\"o\">=<\/span> <span class=\"n\">aPrenom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"n\">String<\/span> <span class=\"nf\">nomComplet<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"k\">return<\/span> <span class=\"n\">prenom<\/span> <span class=\"o\">+<\/span> <span class=\"s\">\" \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nom<\/span><span class=\"p\">;<\/span>\r\n    <span class=\"p\">}<\/span>\r\n\r\n    <span class=\"kd\">public<\/span> <span class=\"kt\">void<\/span> <span class=\"nf\">bonjour<\/span><span class=\"p\">(){<\/span>\r\n        <span class=\"n\">System<\/span><span class=\"p\">.<\/span><span class=\"na\">out<\/span><span class=\"p\">.<\/span><span class=\"na\">println<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Bonjour \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">nomComplet<\/span><span class=\"p\">());<\/span>\r\n    <span class=\"p\">}<\/span>\r\n<span class=\"p\">}<\/span>\r\n<\/pre>\n<\/div>\n<p>En effet, on voit qu&rsquo;au lieu d&rsquo;assigner les cha\u00eenes de caract\u00e8res vides directement dans le constructeur \u00ab\u00a0Personne()\u00a0\u00bb, ce dernier appel le constructeur \u00ab\u00a0Personne(String aPrenom, String aNom)\u00a0\u00bb avec comme arguments les cha\u00eenes vides.<\/p>\n<h2>Diagramme de classe<\/h2>\n<p>Dans le standard UML, on appelle diagramme de classe un diagramme permettant de repr\u00e9senter, de mani\u00e8re visuelle, le \u00ab\u00a0desing\u00a0\u00bb des classes du syst\u00e8me \u00e0 d\u00e9velopper.<\/p>\n<p>Dans un diagramme de classe, une classe est pr\u00e9sent\u00e9e comme une boite contenant 3 sections horizontales: une pour le nom, une pour les attributs et une pour les m\u00e9thodes et constructeurs.<\/p>\n<p>Les liens clients\/fournisseurs peuvent se faire de diff\u00e9rente fa\u00e7on. Afin de garder ces diagrammes simple dans le cadre du cours, nous allons pr\u00e9senter ce type de liens avec une fl\u00e8che (avec une pointe vide et non ferm\u00e9e). La direction du lien se fait \u00e0 partir du fournisseur vers le client.<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-12274 aligncenter\" src=\"https:\/\/www.louismarchand.me\/wp-content\/uploads\/2021\/05\/diagramme_classe.png\" alt=\"\" width=\"523\" height=\"122\"><\/p>\n<p>Vous pouvez voir que j&rsquo;ai utilis\u00e9 le nom de m\u00e9thode \u00ab\u00a0nom_complet\u00a0\u00bb et non \u00ab\u00a0nomComplet\u00a0\u00bb. Il est important de consid\u00e9rer un diagramme de classe comme \u00e9tant ind\u00e9pendant du langage \u00e0 utiliser. Donc, il n&rsquo;est pas n\u00e9cessaire de respecter le standard du langage.<\/p>\n<p><a href=\"https:\/\/www.louismarchand.me\/index.php\/programmation-orientee-objet-1\/\">Retour<\/a><\/p>\n<p>&nbsp;<\/p>\n<hr>\n<p>Auteur: Louis Marchand<br \/>\n<a href=\"https:\/\/creativecommons.org\/licenses\/by\/4.0\/deed.fr\" target=\"_blank\" rel=\"license noopener noreferrer\"><img decoding=\"async\" src=\"https:\/\/i.creativecommons.org\/l\/by\/4.0\/80x15.png\" alt=\"Creative Commons License\"><\/a><br \/>\nSauf pour les sections sp\u00e9cifi\u00e9es autrement, ce travail est sous licence <a href=\"https:\/\/creativecommons.org\/licenses\/by\/4.0\/deed.fr\" target=\"_blank\" rel=\"license noopener noreferrer\">Creative Commons Attribution 4.0 International<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Un bref historique Simula Cr\u00e9\u00e9 en 1962 par Ole-Johan Dahl et Kristen Nygaard Langage de simulation Bas\u00e9 sur Algol60, un langage proc\u00e9dural utilis\u00e9 dans les ann\u00e9es 1960 L&rsquo;invention du concept objet par accident L&rsquo;objectif du langage \u00e9tait de simuler des objets de la vie r\u00e9elle. M\u00eame s&rsquo;il s&rsquo;agit du premier langage-objet, son impl\u00e9mentation objet est&hellip; <a class=\"more-link\" href=\"https:\/\/www.louismarchand.me\/index.php\/la-programmation-orientee-objet\/\">Continue reading <span class=\"screen-reader-text\">La programmation orient\u00e9e objet<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-60","page","type-page","status-publish","hentry","entry"],"_links":{"self":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/60","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/comments?post=60"}],"version-history":[{"count":4,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/60\/revisions"}],"predecessor-version":[{"id":564,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/60\/revisions\/564"}],"wp:attachment":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/media?parent=60"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}