En programmation orientée objet, il existe un concept très important à respecter le plus possible pour s'éviter toute sorte de problèmes, c'est le principe d'encapsulation des données. Mais qu'est-ce que c'est ? Wikipédia nous dit :
Citation : Wikipédia
En programmation orientée objet, l’encapsulation est l'idée de protéger l'information contenue dans un objet et de ne proposer que des méthodes de manipulation de cet objet. Ainsi, les propriétés et axiomes associés aux informations
contenues dans l'objet seront assurés/validés par les méthodes de l'objet et ne seront plus de la responsabilité de l'utilisateur extérieur. L'utilisateur extérieur ne pourra pas modifier directement l'information et risquer de mettre en péril les axiomes et les propriétés comportementales de l'objet.
L'encapsulation des données consiste donc à ne pas mettre au jour les données caractéristiques d'un objet. Ainsi, les attributs d'un objet ne doivent pas être manipulés directement par l'utilisateur. En clair, lorsque vous utilisez un objet, vous utilisez une boîte noire munie d'une interface.
Mais alors, ça sert à quoi de créer des objets, d'y stocker des données si je ne peux pas y accéder ?!
Et bien, les méthodes qui peuvent être appliquées à l'objet sont l'interface entre un modèle (attributs et axiomes) et l'utilisateur final, vous. Les données ne pourront être manipulées que via des méthodes. Les méthodes qui permettent d'accéder ou de modifier les attributs sont respectivement appelées accesseurs et mutateurs. Vous verrez dans la suite que ce sont des méthodes différenciées uniquement par des conventions.
L'exemple le plus utilisé pour illustrer l'encapsulation est celui des nombres complexes. Ce sont des nombres que l'on peut écrire de façon cartésienne ou polaire. Dans un cas comme dans l'autre, on peut en obtenir des informations comme la partie réelle, la partie imaginaire, le module, l'argument, etc... Seulement, suivant s'il est stocké en mémoire sous forme cartésienne ou polaire, ces données ne s'obtiennent pas de la même façon. Mais finalement, est-ce que cela intéresse l'utilisateur final ? Et bien non, lui, il n'a besoin que de savoir qu'il peut récupérer ces informations quoiqu'il arrive ! Le modèle est donc pour lui transparent. Il ne le perçoit pas.
Pour ceux d'entre vous qui n'ont pas forcément compris l'exemple des nombres complexes, vous pouvez considérer votre ordinateur. Le modèle, c'est ce qu'il y a dans votre ordinateur, les opérations que peut effectuer votre processeur tout ça. L'interface, c'est le clavier, la souris et l'écran. Et vous pouvez appliquer des méthodes à votre ordinateur à l'aide d'applications. Avez-vous besoin de savoir comment fonctionnent les applications et votre ordinateur pour les utiliser ? Dans la plupart des cas, pas du tout ! Le modèle est totalement transparent une fois de plus ! Votre matériel respecte donc le principe d'encapsulation !
En conclusion, il faut toujours cacher votre modèle à l'utilisateur ! Nous verrons dans le chapitre de pratique comment le faire.
C'est la classe !
Ce que nous avons vu jusqu'à maintenant en manipulant les listes, les dictionnaires, etc... c'est qu'il est possible de créer plusieurs objets d'un même type et qu'il est aussi possible de définir de nouveaux types de données. Pour faire cela, il faut donc une sorte d'usine à objet : une classe. Une classe est ce qui sera défini pour la création d'objets. Les objets ainsi créés sont appelés instances.
Pour les fans de MMORPG (prononcé Meuporg selon certains journalistes...), vous comprenez certainement mieux le nom d'instance qui est donné aux donjons dont une nouvelle instance est créée pour chaque groupe de joueurs !
Sur ce schéma, vous passez votre commande (instanciation/création d'instance), et l'usine (la classe) vous fabrique les objets que vous avez demandé avec les caractéristiques demandées. Tous les objets issus d'une même classe ont tous les mêmes attributs mais ces attributs n'auront pas forcément les mêmes valeurs d'une instance à une autre ! Toutes les boîtes sont des boîtes mais n'ont pas la même couleur par exemple. La classe est donc le nouveau type de donnée que vous désirez créer. Elle vous permettra de créer autant d'instances que vous le désirerez. Dans la partie pratique, nous verrons donc comment définir tout ce que nous avons vu dans ce chapitre :
Des classes : pour créer de nouveaux types de donnée Les attributs : les différents types et comment les définir Les méthodes : les différents types et comment les définir
Les accesseurs et les mutateurs : les créer en respectant les conventions Le constructeur : pour créer des instances
Les instances : comment les créer et les manipuler
Certains de ces termes ne seront définis que dans la suite et tous seront explicités avec des exemples de code. Ils sont à connaître car ce sont les termes techniques dont vous aurez besoin pour comprendre la suite du cours !
Bien, maintenant que vous avez une petite idée de ce qu'est la programmation orientée objet, nous allons voir ce que cela donne en pratique avec la création de vos propres objets ! Parce que c'est bien joli de faire de la théorie, mais si on n'en fait rien, je n'en vois pas l'intérêt !