Ce cours introduit la programmation orientée objet (encapsulation, abstration, héritage, polymorphisme) en l'illustrant en langage C++. Il présuppose connues les bases de la programmation (variables, types, boucles, fonctions, ...). Il est conçu comme la suite du cours « Initiation à la programmation (en C++) ». Comme son prédécesseur, ce cours s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Encapsulation et abstraction : résumé
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Introduction à la programmation orientée objet (en C++)
197 notes
École Polytechnique Fédérale de Lausanne
197 notes
À partir de la leçon
Introduction à la Programmation Orientée Objet
Cette semaine vous accueille dans le cours et vous présente les premiers concepts de base de la programmation dite « orientée objet ».
Rencontrer les enseignants
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Dans les séquences vidéos précédentes, vous avez appris à écrire une classe en c ++
vous savez définir des méthodes et des attributs,
et vous savez mettre en place un certain nombre de fondamentaux
liés à l'encapsulation.
A savoir définir ce qui est publiquement accessible
pour un utilisateur externe de la classe,
et ce qui ne l'est pas.
Nous allons étudier comment tout cela se met en place concrètement,
sur un certain nombre d'exemples.
Et nous allons voir que bien encapsuler nécessite de prendre
un certain nombre de précautions.
Pour rappel, à ce stade, une classe n'est autre qu'une super structure,
dans lequel vous pouvez mettre non seulement des champs,
que l'on appelle des attributs,
mais aussi des fonctions, que l'on appelle désormais des méthodes.
Nous avons vu, qu'une des particularités d'une classe, par rapport aux structures,
c'est qu'il est possible de définir ce qui ne doit pas être accessible
au monde extérieur, ce qui est privé,
et ce qui est à contrario, accessible, c'est-à-dire public.
Voici donc une implémentation possible de la fameuse classe Rectangle,
qui nous a servi d'exemple introductif aux concepts fondamentaux
de l'orienté objet.
Donc lorsque l'on veut définir une classe, on utilise le mot réservé "classe",
suivi du nom que l'on a choisi pour la classe.
Comme désormais, ce nom va être un nom de type dans le programme,
il est l'usage de le nommer en commençant par une majuscule.
Une classe est usuellement caractérisée par un certain nombre
de données spécifiques que l'on appelle les attributs.
Ici, nous avons choisi de caractériser la classe Rectangle
au moyen d'un attribut hauteur et largeur,
que nous avons choisi d'implémenter
sous la forme de deux doubles.
Une classe est également caractérisée par un certain nombre
de fonctionnalités spécifiques, que l'on appelle les méthodes.
Une fois que l'on a établi les éléments fondamentaux,
que sont les attributs et les méthodes, il faut se pencher sur la question
de ce qui constitue parmi ces éléments, un aspect d'implémentation interne
qui n'a pas besoin d'être connu du monde extérieur,
et ce qui constitue l'interface d'utilisation, ce que le monde extérieur
aura besoin de connaître et ce qu'il peut utiliser
de la classe en question.
Ici, nous avons choisi d'offrir comme fonctionnalité au monde extérieur,
un certain nombre de méthodes permettant de consulter
la valeur des attributs largeur et hauteur,
de les modifier et de faire un calcul de surface,
qui utilise cette largeur et cette hauteur.
Les éléments qui font partie de l'interface sont étiquetés
comme étant "publics".
A contrario, nous avons étiqueté comme "private" tout ce qui est considéré
comme détail d'implémentation,
et c'est usuellement le cas pour les attributs.
Notez qu'il n'est généralement pas nécessaire
de systématiquement définir des méthodes "get" et "set",
pour chacun des attributs de la classe.
Ici, nous ne l'avons fait que parce que à ce stade de l'apprentissage,
nous ne savons interagir avec le contenu de la classe,
que de façon très basique.
Donc nous avons notamment besoin de ces méthodes "set",
pour mettre des valeurs appropriées,
dans les attributs largeur et hauteur.
Respecter les principes d'une bonne encapsulation,
en déclarant comme privé, ce qui relève de l’implémentation,
comme typiquement la représentation des attributs dans une classe,
va permettre aux programmeurs concepteurs de la classe rectangle,
de lui donner la latitude de modifier son implémentation,
sans que ceci n'ait d'impact sur celui qui utilise la classe rectangle.
Par exemple, si le programmeur de la classe rectangle
décide de modifier son implémentation,
ici au lieu d'utiliser deux doubles, on pourrait imaginer qu'il utilise
plutôt un tableau à deux éléments, comme ceci.
Donc il lui suffit d'adapter en interne, l'implémentation de ces méthodes,
par exemple ici, au lieu d'avoir un return hauteur,
on aurait plutôt un return de dims[0].
Il lui suffit donc d'adapter l'implémentation de ces méthodes,
pour que le code continue à être complètement fonctionnel
pour celui qui l'utilise, sans qu'il ne voit jamais
quelles modifications ont été apportées à l'implémentation.
Notez aussi que puisque l'utilisateur externe de la classe Rectangle,
n'a d'accès aux données de la classe Rectangle,
que via une interface bien spécifique,
il devient désormais possible de contrôler comment se fait cet accès,
de façon bien précise.
Avez-vous une idée de comment on pourrait améliorer le code
de la classe Rectangle, que vous avez sous les yeux,
par rapport à ce point ?
Le code que vous avez sous les yeux,
correspond ici aux code produit par le programmeur concepteur
de la classe Rectangle,
voyons ce qui se passe du côté du programmeur utilisateur.
Donc ça peut être la même personne qui a défini la classe Rectangle,
et qui l'utilise, mais pas forcément.
Voici maintenant, un programme principal, qui lui est client
de la classe Rectangle, qui a été définie sur les transparents précédents.
Donc la classe Rectangle définit désormais un nouveau type, qui est utilisable,
comme tous les autres types, que nous avons eu l'habitude
d'utiliser jusqu'ici.
Nous pouvons déclarer une variable de type Rectangle,
que l'on appelle usuellement un objet, une instance,
et commencer à travailler avec.
Lorsque cette ligne a terminé de s'exécuter,
nous disposons en fait en mémoire,
d'un objet, de type Rectangle, qui a deux champs, deux attributs,
un pour la largeur, et un pour la hauteur.
Donc la première chose à laquelle il faut raisonnablement penser,
c'est d'initialiser proprement ces deux champs,
pour pouvoir travailler avec un rectangle, qui a des dimensions concrètes.
L'initialisation d'un objet, à proprement parler, est tout un volet,
dont nous aurons l'occasion de reparler prochainement dans le détail.
Pour l'heure, nous allons nous contenter
d'affecter des valeurs aux attributs souhaités.
L'affectation de la largeur et de la hauteur,
peut se faire tout simplement au moyen d'une interaction clavier.
Donc on va demander à l'utilisateur d'introduire une valeur pour la hauteur,
une valeur pour la largeur, que l'on va lire dans une variable
préalablement déclarée, et que l'on va mettre à l'intérieur
des champs du rectangle, au moyen des fonctionnalités,
que l'on a préalablement prévues.
Donc imaginez ici que l'utilisateur introduise la valeur 5.0
dans la variable lue, en utilisant la fonctionnalité setHauteur,
par le biais de la notation pointée,
qui veut dire ici, mettre la hauteur du rectangle à la valeur lu.
Nous aboutissons donc à cette situation concrètement.
Et pareil ici, pour la largeur.
Par exemple ici.
Une fois que le rectangle est proprement initialisé,
il est possible d'invoquer d'autres fonctionnalités sur ce rectangle,
comme typiquement ici, le calcul de la surface,
et on passe toujours par la fameuse notation pointée
qui signifie ici, je calcule la surface du rectangle.
Et voici pour finir, une écriture affinée de la classe Rectangle,
qui tire partie de l'externalisation de la définition des méthodes.
Donc ici les méthodes sont uniquement prototypées dans la classe rectangle,
leur définition est placée à l'extérieur de la classe Rectangle.
Le lien entre la méthode et la classe à laquelle elle appartient,
est fait au moyen de l'opérateur de résolution de portée.
L'opérateur de résolution de portée (::), permet donc ici de lier un nom local,
qui est le nom par exemple d'une méthode appartenant à la classe,
avec un nom plus global, qui est celui de la classe
à laquelle cette méthode appartient.
L'intérêt d'externaliser, est que la déclaration de la classe est désormais
épurée de tous les détails de la définition des méthodes.
Donc cette façon de déclarer la classe en y mettant uniquement
le prototype des méthodes, et bien évidemment, les attributs,
va constituer ce que l'on appelle, le prototype de la classe.
Les définitions des méthodes, l'ensemble des définitions des méthodes de la classe,
vont constituer la définition de la classe.
Donc exactement pareil que ce que l'on a vu avec les fonctions,
le prototype est ce qui va permettre
l'accord entre le programmeur utilisateur et le programmeur concepteur
de la classe Rectangle.
Les définitions ne sont connues que du programmeur concepteur.
Celui qui utilise la classe Rectangle
n'a besoin de connaître que la partie publique de son prototype.
Notez que dans une bonne conception, on prendra soin de marquer comme const,
tout ce qui n'est pas un manipulateur,
tout ce qui n'est pas amené à modifier la valeur des attributs.
Plusieurs petits détails peuvent être remarqués ici,
notamment le fait que certains programmeurs
jugent utile d'adopter une convention
de nommage particulière pour les attributs,
comme le fait de les terminer par le caractère souligné.
Donc c'est pour éviter d’éventuels masquages
avec des noms d'arguments de méthode.
Vous noterez également ici, la façon particulière
qu'a le programmeur de nommer ses accesseurs et ses manipulateurs.
Dans la version précédente du programme,
la méthode qui permettait d'accéder à l'attribut hauteur du Rectangle,
s'appelait getHauteur,
ici elle s'appelle hauteur tout court.
Pareil pour la largeur.
De même, la méthode qui permettait de modifier la valeur de l'attribut hauteur,
en y mettant une valeur particulière dedans,
s'appelait setHauteur, ici elle s'appelle hauteur tout court.
Certains programmeurs trouvent cette façon de nommer
les accesseurs et les manipulateurs,
plus claire, plus lisible, au niveau de l'utilisation.
Par exemple, ici, si dans un programme qui utilise la classe Rectangle,
je veux faire afficher la hauteur d'un rectangle donné,
qui aurait été préalablement déclarée,
donc ici, il me suffit d'écrire rect.hauteur().
Je n'ai pas besoin d'écrire rect.get.hauteur(),
ce qui est un peu plus lourd.
De même si je veux modifier dans un programme qui utilise
la notion de rectangle, la hauteur d'un rectangle donnée,
j'écrirai tout simplement ceci,
ce qui est jugé comme plus lisible et plus clair
par certains programmeurs.
On utilise bien évidemment ici le mécanisme de surcharge,
le fait de donner le même nom à deux méthodes différentes,
mécanisme de surcharge qui est possible
pour les méthodes d'une classe,
comme il l'est pour les fonctions usuelles.
Donc il n'y a pas de confusion possible au niveau de l'appel.
La méthode hauteur ici, qui est un manipulateur se distingue
de la méthode hauteur, qui est un accesseur,
par la liste des arguments, qui est différente dans les deux cas,
mais également par la présence ou non du modificateur const.
Donc pas de confusion possible au moment de l'appel à ces méthodes.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
