Si vous débutez en programmation ou explorez divers langages, vous avez sûrement entendu parler de la "programmation orientée objet" (POO ou OOP en anglais).
De nombreuses explications techniques existent, mais ici, nous décomposons les bases de la POO de manière simple et accessible.
Pour bien saisir la programmation orientée objet, il faut d'abord comprendre ce qu'elle a remplacé. Les premiers langages étaient procéduraux : le programmeur définissait une série d'instructions précises que l'ordinateur exécutait étape par étape.
Au départ, ces instructions étaient même codées sur des cartes perforées. Elles prenaient des données en entrée, les transformaient via une séquence d'opérations, et produisaient de nouvelles données en sortie.
Les langages procéduraux ont bien servi pendant des décennies (et sont encore utilisés). Cependant, pour des projets complexes au-delà de tâches basiques, ils deviennent vite ingérables. C'est là que la POO entre en scène.
Qu'est-ce que la programmation orientée objet ?
Le premier langage POO reconnu, Simula, a introduit le concept d'objets : des regroupements d'informations traités comme une entité unique.
Nous y reviendrons avec un exemple concret, mais d'abord, parlons des classes. Une classe est comme un modèle ou un blueprint : elle définit une liste d'attributs qui, une fois instanciés, forment un objet.
Imaginons un jeu d'échecs. Une classe Pièce pourrait inclure ces attributs :
Un objet représente une instance spécifique de cette classe, comme ReineBlanche : blanche, grande, forme cylindrique crantée, mouvements libres en diagonale ou droite.
Elle peut aussi inclure des méthodes (fonctions associées).
Pourquoi est-ce supérieur à l'approche procédurale ? Les langages POO comme Java organisent données et code de façon plus flexible et scalable pour les gros projets.
Approfondissons avec les quatre piliers de la POO.
Vous n'avez pas besoin de tout comprendre pour utiliser un objet. Une machine à espresso est complexe, mais il suffit d'appuyer sur "On" pour obtenir votre café.
Dans la POO, une méthode comme move() gère internement positions, captures, etc. Vous n'avez qu'à l'invoquer : la pièce bouge. C'est l'abstraction.
L'encapsulation crée l'abstraction en regroupant données (variables) et méthodes dans un objet traité comme une "boîte noire".
Les variables sont souvent privées (inaccessibles directement), modifiables uniquement via des méthodes publiques.
Pour un Fou (Bishop) : variable privée position utilisée par move() publique, et couleur protégée. Cela évite les modifications accidentelles et permet des changements internes sans impacter l'extérieur.
Les langages POO supportent les sous-classes qui héritent des attributs de la classe parent, tout en ajoutant les leurs.
Dans les échecs, un pion a une méthode transformPiece() si il atteint la dernière rangée. Pas besoin de l'ajouter à toutes les pièces : créez une sous-classe Pion héritant de Pièce, plus cette méthode.
L'héritage évite la redondance, mais un usage excessif peut compliquer le code.
Le polymorphisme découle de l'héritage : une même méthode s'adapte aux objets.
La classe Pièce a move() basique. Une sous-classe Tour redéfinit move() pour mouvements illimités horizontaux/verticaux.
En invoquant move(tour), le programme exécute la version appropriée automatiquement. Gain de temps énorme !
Voici l'essentiel :
Ces piliers semblent ardus au début, mais deviennent intuitifs avec la pratique.
Cet article couvre les généralités. Chaque langage POO (Java, Python, etc.) a ses nuances. Choisissez-en un et plongez-vous dedans !
Apprenez ensuite à structurer votre code POO efficacement.
