Comprendre la programmation orientée objet en 5 minutes

Si tu es là c’est que tu as passé un stade. C’est que tu as déjà compris les bases du développement. Tu maitrises les variables, les fonctions, les algorithmes et tu souhaiterais passer au niveau supérieur, maitriser la fameuse programmation orientée objet.

Mais ça te tracasse un peu. Tu n’y vois pas bien claire dans tout ça, tu te poses des questions, tu ne comprends pas vraiment comment ça fonctionne ni par où commencer.

Ça tombe bien, cet article est là pour répondre à toutes tes questions. Nous allons démystifier ensemble la programmation orientée objet. Et pour cela on va partir de choses très simples. On va commencer par mettre la technique de côté et voir ensemble des exemples qui vont te faire comprendre rapidement les principes de la programmation objet.

La programmation orientée objet, c’est pour moi la « majorité du développeur ». Un peu comme lorsque tu viens d’avoir 18 ans, tu deviens un adulte, tu as passé un stade. La programmation orientée objet, c’est la même chose. Tu vas passer un stade et ta façon de coder vas changer. Tu vas devenir « un grand » 😉

Pour commencer, c’est quoi un objet ?

Pourquoi on utilise ce terme d’objet dans la programmation ? C’est quoi un objet ?

Regardes autour de toi. Qu’est-ce que tu vois ?

Réponse : des objets

A quoi sert le code ?

Réponse : à répondre à des problématiques de la vie du quotidien.

Alors, les objets vont nous permettre de solutionner les problématiques du quotidien. C’est un peu comme si on allait utiliser de vrais objets dans notre code.

Oublie le côté technique un instant. Imagine que tu as le projet d’ouvrir un restaurant. Dans ce restaurant, il va falloir que tu utilises des objets pour le créer : des chaises, des tables, des plateaux, des fours, des assiettes, des couverts, etc …

Et tous ces éléments tu vas les personnaliser. Par exemple, tu vas prendre un modèle précis de table, avec certaines propriétés : de couleur rouge, avec 4 pieds, d’une largeur de 90 cm, d’une longueur de 120 cm, d’une hauteur de 76 cm, avec des bords arrondis.

Tu peux imaginer cette personnalisation pour tous les autres objets de ton restaurant : les chaises, les assiettes, …

Dans l’informatique c’est pareil. On va utiliser les objets de la même façon. Lorsque l’on va créer un projet, on va se demander de quel objet on a-t-on besoin et quelles sont, pour chaque, objet ces propriétés. Et l’avantage avec l’informatique c’est qu’absolument tous les objets peuvent être coder.

Un objet est donc un ensemble de propriétés (comme la couleur, la longueur, la largeur pour la table). Toutes ces propriétés réunis vont créer un objet particulier.

Pour le moment tu commences peut-être à comprendre un petit peu ce qu’est la programmation orientée objet mais j’imagine que c’est encore un peu flou. Ne t’inquiète pas, à la fin de cet article, tu seras capable d’imaginer et créer tes propres objets.

Qu’est-ce qu’une propriété ?

Comme je le disais précédemment, un objet est constitué de propriétés et c’est d’ailleurs l’essence même de la programmation orientée objet. Lorsque l’on définit un objet, on lui assigne un ensemble de propriétés.

Reprenons l’exemple de notre restaurant avec nos tables. Dans notre restaurant, on souhaite avoir des tables de différentes tailles pour pouvoir accueillir des couples, des familles, des groupes d’amis etc… On va donc avoir besoin de tables dont les propriétés sont différentes, notamment la longueur, la largeur, la couleur, le nombre de pieds ….

Si on imagine ça d’un côté plus technique, plus informatique, on aurait quelque chose comme ça :

Objet Table

• Largeur
• Longueur
• Couleur
• Nombre de pieds

Voilà, on vient de créer notre premier objet. Bien sûr c’est une façon simplifiée de « coder » un objet mais l’idée est là. Tu commences à toucher du bout du doigt à la programmation orientée objet.

Ce qu’il faut comprendre ici, c’est que les propriétés sont toutes les caractéristiques qui peuvent être modifiés dans un objet. C’est toutes ces propriétés interchangeables qui vont nous permettre de créer des objets différents.

Par exemple, si l’on prend « une personne », quelles sont les caractéristiques qui vont changer d’une personne à l’autre ?

• Le prénom
• Le nom
• La date de naissance
• Son adresse
• Son numéro de téléphone
• …

Avec tous ces éléments, on pourrait donc créer un objet « Personne » qui aurait toutes ces propriétés. A travers cet exemple, tu comprends aussi que les objets, ne sont pas uniquement des objets matériels. Ils peuvent être plus abstrait et représenter n’importe quoi.

Je t’invite à faire l’exercice d’écrire l’ensemble des propriétés de ces différents objets :

• Voiture
• Ordinateur
• Maison

Tu peux aussi, prendre n’importe quel autre objet et essayer de faire l’exercice.

Ce qu’il faut comprendre : il est possible de définir une liste immense de propriétés pour un seul objet. Bien sûr, lorsque l’on va coder nos objets, il ne va pas falloir créer toutes ces propriétés. On ne va créer que celles qui nous sont utiles. Par exemple, si on a un objet « Personne » et que l’on souhaite uniquement utiliser les propriétés « nom », « prénom » et « date de naissance » , il n’y a pas besoin d’en rajouter plus.

Dans nos exemples précédents, nous avons uniquement listé les propriétés. En réalité, nous n’avons pas vraiment créer d’objet. Nous avons simplement défini la structure de notre objet.

Comment utiliser des objets ?

Le réel intérêt de la programmation orientée objet réside dans l’utilisation de cette structure pour créer des objets, plus précisément des instances d’objet.

Pour le moment, nous n’avons pas encore nos tables pour les couples, les familles et les groupes d’amis. Nous avons simplement créé le « moule » pour créer toutes nos instances d’objet.

Je trouve que cette image est très parlante. Pour le moment, nous avons simplement créer le moule qui vas nous permettre de créer des objets à l’infini. Une fois que le moule est créé, il peut être utilisé pour créer plein d’objets. Et c’est ce que l’on va faire de suite avec nos tables. On va pouvoir créer plein de tables. Et l’avantages avec notre « moule » c’est que l’on peut faire des tables toutes différentes les unes des autres (couleur, taille, nombre de pieds, etc). Et c’est là le réel intérêt de la programmation orientée objet.

Avec notre « moule », on va créer 3 types de tables différentes : des tables pour les couples (assez petite (90cm x 90cm), de couleur rouge, avec 4 pieds), des tables pour les familles (de taille moyenne (150cm x 90cm), de couleur bleu et avec 6 pieds) et des tables pour les groupes d’amis (de grande taille (300cm x 90cm), de couleur vert avec 10 pieds)

Pour cela, on va créer des instances de notre objet « Table » dans lesquelles on vas venir attribuer des valeurs à chacune des propriétés de notre objet. Une instance est simplement la déclaration d’un nouvel objet. Cette instance est mise dans une variable.

TableCouple = nouvelle Table(90, 90, 'rouge', 4)
TableFamille = nouvelle Table(150, 90, 'bleu', 6)
TableAmis = nouvelle Table(300, 90, vert', 10)

WHAOUH, c’est quoi tout ça ?!!

J’imagine que cette écriture est un peu bizarre pour toi. Ici, j’ai créé du « pseudo code » pour t’expliquer comment créer des objets dans du code.

Pour t’expliquer :

• TableCouple, TableFamille, TableAmis, sont des noms de variables. Ces noms sont choisis de manière arbitraire
• « nouvelle Table » : dans la programmation orientée objet, lorsque l’on créé une nouvelle instance d’objet, on vas utiliser le mot « new » suivi du nom de l’objet que l’on souhaite instancier (déclarer). Ici j’ai donc utiliser « nouvelle » pour remplacer « new »
• (90, 90, ‘rouge’, 4) : on va ensuite lui passer les propriétés qui vont définir notre objet. Ici on lui passe en premier la largeur (90), puis la longueur (90), puis la couleur ‘rouge’), puis le nombre de pied (4). Cette attribution des valeurs dans notre instance se fait grâce à ce que l’on appelle « un constructeur ». Le constructeur est une fonction de notre objet qui vas définir l’ordre dans lequel on doit passer les propriétés et qui vas attribuer la valeur passée à la propriété correspondante. Nous verrons un peu plus bas, comment créer un constructeur.

On va donc se retrouver avec les objets suivants :

Variable TableCouple

• Largeur : 90
• Longueur : 90
• Couleur : ‘rouge’
• Nombre de pieds : 4

Variable TableFamille

• Largeur : 150
• Longueur : 90
• Couleur : ‘bleu
• Nombre de pieds : 6

Variable TableCouple

• Largeur : 300
• Longueur : 90
• Couleur : ‘vert
• Nombre de pieds : 10

Maintenant, je vais te montrer le même exemple en PHP :

class Table{

	public function __construct(int $larg, int $long, string $coul, int $nbPied){
		$this->largeur = $larg;
		$this->longueur = $long;
		$this->couleur = $coul;
		$this->nombrePied = $nbPied;
	}
	private $largeur;
	
	private $longueur;
	
	private $couleur;
	
	private $nombrePied;
}

$tableCouple = new Table(90, 90, "rouge", 4);
$tableFamille = new Table(150, 90, "bleu", 6);
$tableAmis = new Table(30, 90, "vert", 10);

A la ligne 1, on donne indique que l’on va créer un objet avec le mot clé « class », on lui donne ensuite le nom « Table ».

De la ligne 3 à 8, on créé une fonction qui est notre constructeur. Comme je l’ai dit, le constructeur sert à définir l’ordre dans lequel vont être passées les propriétés. Il attribue ensuite chacune des valeurs passées dans la fonction aux différentes propriétés de l’objet. Ici, le premier paramètre attendu (« $larg ») est la largeur de la table. Ce paramètre est ensuite attribué à la propriété « largeur » de notre classe : $this->largeur = $larg. « $this->largeur » fait référence à la propriété « private $largeur » de notre objet. On lui attribue donc la valeur « $larg » passée dans le constructeur.

De la ligne 9 à la ligne 15, on déclare les propriétés de notre objet. Pour ne pas te donner trop d’informations, je ne vais pas expliquer à quoi correspond « private ».

De la ligne 18 à 20, c’est là que nous créons nos instances de l’objet « Table ». C’est à ce moment que l’on donne vie à nos objets. Pour déclarer une nouvelle instance, on utilise de mot « new », suivi du nom de la classe. On ajouter ensuite les valeurs que l’on souhaite donner à notre table en respectant l’ordre du constructeur (larg, long, coul, nbPied)

Pourquoi utiliser la programmation orientée objet et dans quel cas ?

C’est bien beau d’avoir des objets mais qu’est ce qu’on en fait ? Qu’est ce que ça vas réellement nous apporter ? Comment la programmation orientée objet va changer ma vie ?

Si on reste sur notre exemple de table, imagine que tu souhaites créer une application web pour créer des plans de maison (ou aménager des restaurants). Le but est d’arriver sur un plan, de définir les dimensions de ce plan et de venir y glisser déposer des meubles dont on peut ensuite personnaliser la taille. Un peu comme le site https://home.by.me/ qui propose de faire des plans 3D.

Ici, je viens d’ajouter une table que je peux ensuite personnaliser. Il existe tout un tas d’objets que je peux ajouter dans le plan. Dans leur code, ils ont définit des objets et leurs propriétés : table, chaise, fauteuil, …). Par la suite, je peux mettre autant de table que je veux dans mon plan (en créant de nouvelles instances) et venir modifier les propriétés de mon objet. Bien sûr tout cela est invisble pour l’utilisateur mais c’est ce qu’il se passe dans le code.

Maintenant, imagine que la programmation orientée objet n’existe pas. Pour faire la même chose, il aurait fallu faire ça de façon « procédurale ». C’est-à-dire écrire des procédures ou des fonctions dans notre code pour arriver au même résultat. Avec la manière procédurale, le code aurait été beaucoup moins maintenable et beaucoup moins facile à manipuler.

La programmation orientée objet est une façon logique d’organiser notre code. C’est une programmation qui se rapproche de la vie réelle et qui permet aux développeur de structurer leurs pensées plus facilement dans le code.

Lorsque l’on commence un nouveau projet, il est plus facile de réfléchir en terme d’objet, qu’en terme de procédure et fonction dans le code.

Un cas concret

Pour bien comprendre l’intérêt de la programmation orientée objet, nous allons prendre un cas concret de projet dans lequel on vas utiliser des objets.

Imaginons que l’on souhaite créer un site de e-commerce pour vendre des produits en ligne. La première chose à faire, vas être de définir l’ensemble des objets que l’on va utiliser dans notre projet.

Je le rappelle, les objets, ne sont pas forcément des objets matériels. Il faut voir les objets dans un sens beaucoup plus global : « tout ce qui existe sur la terre ». Ça fait un peu enfant comme phrase mais c’est vraiment ça.

Voici la liste des objets que l’on va devoir avoir dans notre projet de e-commerce :

• Produit avec comme propriétés : nom, description, prix
• Personne avec comme propriétés : prénom, nom, date de naissance, adresse postale, email, numéro de téléphone
• Commande : numéro de commande, date de commande, liste des produits commandés, personne qui a commandé.

Tu comprends avec cet exemple, que l’utilisation de la programmation orientée objet ne se limite pas à la création d’objet matériel. Il faut vraiment voir ça de façon plus large et se demander : « qu’est ce qu’il va y avoir dans mon application en ligne ? » et « quels sont les propriétés dont j’ai besoin pour chaque objet que je vais créer ». 

Aussi, tu as peut-être remarqué que dans l’objet « Commande », j’ai mis « liste des produits commandés ». En effet, il peut y avoir des liens entre les objets. Dans notre objet « Commande », la propriété « produitsCommandés » serait un tableau qui contiendrait différentes instances de « Produit ». Je le rappelle, les instances d’un objet, sont simplement des variables. De même pour la propriété « personne qui a commandé », on donnera à cette propriété la valeur de l’instance de la personne qui a commandé.

Pour mieux comprendre, je vais te le montrer sous forme de « pseudo code ».

Objet Personne{

	Propriété nom
	Propriété prénom
	Propriété date de naissance

	Function Constructeur(n, p, ddn){
		Attribuer à la propriété nom la valeur n
		Attribuer à la propriété prénom la valeur p
		Attribuer à la propriété date de naissance la valeur ddn
	}
	Function changerNom(n){
		Attribuer à la propriété nom la valeur n
	}
	Function changerPrenom(p){
		Attribuer à la propriété prénom la valeur p
	}

	Function changerDateDeNaissance(ddn){
		Attribuer à la propriété date de naissance la valeur ddn
	}

}
Objet Commande{

	Propriété numéro de commande
	Propriété date de commande
	Propriété liste des produits commandés
	Propriété personne qui a commandé 

	Function Constructeur(nc, ddc, pc, p){
		Attribuer à la propriété numéro de commande la valeur nc
		Attribuer à la propriété date de commande la valeur ddc
		Attribuer à la propriété produits commandés la valeur pc
		Attriber à la propriété personne la valeur p
	}
	Function changerNumeroDeCommande(nc){
		Attribuer à la propriété numéro de commande la valeur nc
	}
	Function changerDateDeCommande(ddc){
		Attribuer à la propriété date de commande la valeur ddc
	}

	Function changerProduitsCommandés(ddn){
		Attribuer à la propriété produits commandés la valeur pc
	}
	Function changerPersonneQuiACommandé(p){
		Attribuer à la propriété personne qui a commandé la valeur p
	}
}

Variable paul = nouvelle Personne('Dupont', 'Paul', '05/08/1995')
Variable maCommande = nouvelle Commande(2584, '14/04/2021', [produit1, produit2], paul)

On vient de déclarer nos 2 objets « Personne » et « Commande » avec l’ensemble de leurs propriétés. Puis, on a créé un constructeur qui définit l’ordre des paramètres attendus et attribut les paramètres passés à la propriété correspondante. On a aussi créé des fonctions que l’on appelle « setter » qui nous permettrons de venir modifier les valeurs de nos propriétés.

Par exemple, si je souhaite modifier la date de la commande, je ferais :

maCommande-> changerDateDeCommande('12/03/2021')

A ce moment-là, la propriété « date de commande » de mon instance « maCommande », ne vaudra plus ‘14/04/2021’ mais ‘12/03/2021’. Les « setter » sont de simples fonctions qui viennent modifier les valeurs de nos propriétés.

Grâce à tous ces objets, je vais pouvoir développer mon site de e-commerce de façon plus « logique ».

La programmation orientée objet : ce qu’il faut retenir

Lorsque l’on est développeur, il arrive un moment où l’on doit se pencher sur la programmation orientée objet. Aujourd’hui c’est presque une obligation de maitriser ce type de programmation.

En revanche, il n’est pas forcément aisé de la comprendre. La notion d’objet est très abstraite et au début, il est compliqué de comprendre ce lien entre les objets et le code. On se demande souvent : « comment je fais des objets dans du code ? »

La programmation orientée objet est une manière de développer qui se rapproche de « la vraie vie ». Dans notre code, on va créer des objets qui vont permettre de donner un aspect plus « réel » au code.

Nous avons fait le parallèle entre un projet de restaurant dans la vraie vie et dans le code. On a ainsi vu que les objets qu’il fallait coder était identique à ceux utiliser dans la vraie vie.

Lorsque l’on débute un nouveau projet, il faut toujours réfléchir en amont et lister les objets que l’on souhaite utiliser. Il suffit de lister le minimum dont on a besoin. Il n’est pas nécessaire de créer des objets ou des propriétés d’objet que l’on ne va pas utiliser.

Un objet est un ensemble de propriétés qui caractérise cet objet. Ces propriétés peuvent être modifiées à l’aide de fonction « setter ». C’est ce qui donnera le caractère unique à chaque instance d’objet que l’on va créer par la suite.

Une fois maitrisée, la programmation orientée objet deviendra une évidence dans chacun de tes projets. Tu gagneras beaucoup de temps et ton code sera beaucoup plus structuré et maintenable. La programmation orientée objet sera comme une évidence pour toi.

J’espère que cette initiation à la programmation orientée objet t’as permis d’y voir un peu plus clair et de comprendre en quoi elle consiste.