La programmation orientée objet<span class="wtr-time-wrap after-title"><span class="wtr-time-number">14</span> min read</span>
Schéma héritage de la programmation orientée objet

La programmation orientée objet14 min read

On va voir comment fonctionne très précisément la programmation orientée objet (POO ou OOP). Après cet article vous pourrez construire des applications avec ce système très puissant et universel. Comme ça, ça semble très complexe mais en fait c’est plutôt simple de comprendre le fonctionnement de la programmation orientée objet (POO)

C’est quoi la programmation orientée objet ?

C’est une façon de concevoir une application, web ou logiciel d’ailleurs. On as déjà parlé des design patterns et du modèle MVC, et bien ce n’est pas du tout la même chose, ici on ne parles pas d’organisation mais bel et bien de manière de coder.

La programmation orientée objet fonctionne avec un système de class, vous pouvez les voir comme des schémas décrivant précisément la conception d’un objet. L’idée de la programmation orientée objet c’est de simuler le fonctionnement d’objet ou de concepts du monde réel et de pouvoir les faire interagir.

Et c’est à ça que servent les class, créer des objets par rapport au schéma de conception (qui est la class). Une fois l’objet instancié (terme pour dire crée à partir d’une classe) , on peux le faire interagir avec d’autres objets qui proviennent de la même classe ou non.

Comment ça fonctionne une classe ?

Depuis toute à l’heure je parle des classes , j’ai dis que c’était des schémas permettant de créer des objets. On va voir plus en détails comment les classes fonctionnent et comment elles s’utilisent

En gros, créer une classe c’est concevoir un schéma de construction, vous pouvez voir votre classe comme une usine à produire des objets.

Mais alors , qu’est ce qu’un objet et à quoi ça sert exactement ? Et bien des objets quelque soit le langage de programmation vous en avez déjà rencontrés. Que ce soit des arrays, des strings ou des int, ce sont des objets. Ces objets ont une valeur et des méthodes pouvant modifier cette valeur. Par exemple string.toUpperCase() en javascript va mettre la chaîne de caractère en majuscules.

On nomme les fonctions reliés aux objets des méthodes et les valeurs que peuvent contenir des objets des attributs. Ainsi définissons une classe en Javascript. Vous verrez qu’à part en python la syntaxe est presque la même d’un langage à un autre.

class Personnage { // création d'une nouvelle classe Personnage

    constructor() { // méthode lancée a la création de l'objet
        this.name = 'Paul';
        this.age = 40;
    }

    sePresenter() { // création d'une méthode retournant une chaine de caractère
        return `Salut je m'appelle ${this.name} et j'ai ${this.age} ans`
    }
}

let paul =  new Personnage; // création d'un nouveau personnage
console.log(paul.sePresenter()); // appel de la méthode et log

Le code est commenté pour que vous puissiez comprendre mais je vais quand même détailler un peu, d’abord on crée une nouvelle classe appelée Personnage

Ensuite on crée les attributs de cette classe, c’est à dire les variables stockées dans l’objet, on les assigne à des valeurs fixes. Pour se faire on utilise une méthode appelée le constructeur, ici en javascript elle s’appelle constructor(). Mais elle varie d’un langage à un autre. On utilise le mot clé this pour faire référence a l’objet que l’on va créer. Encore une fois ce mot clé peux varier mais c’est généralement this ou self.

Puis on crée une méthode qui retourne simplement une chaine de caractère comportant a l’intérieur les attributs de notre objet. Encore une fois on utilise this pour accéder aux attributs crée précédemment avec la méthode constructrice

Une fois la classe crée on déclare une variable qui instancie la classe. C’est à dire qui crée un objet à partir du schéma de la classe. Ensuite on appelle la méthode sePresenter() sur cette objet, ce qui nous donne :

Salut je m'appelle Paul et j'ai 40 ans

Vous allez voir que l’on peux très facilement accéder aux attributs de l’objet individuellement en faisant simplement objet.attribut

let paul =  new Personnage; // création d'un nouveau personnage
console.log(paul.name)

Ce code ( je n’ai volontairement pas affiché la classe pour ne pas prendre de place) nous renvoi la valeur de l’attribut

Paul

Donc notre objet as des variables attachés ainsi que des fonctions, on va maintenant voir comment personnaliser les attributs de l’objet au moment de la création.

class Personnage { // création d'une nouvelle classe Personnage

    constructor(name, age) { // méthode lancée a la création de l'objet
        this.name = name;
        this.age = age;
    }

    sePresenter() { // création d'une méthode retournant une chaine de caractère
        return `Salut je m'appelle ${this.name} et j'ai ${this.age} ans`
    }
}

let michel =  new Personnage('Michel', 32); // création d'un nouveau personnage
console.log(michel.sePresenter());

On as quasiment rien modifié, seulement notre méthode constructrice, a l”intérieur on donne deux arguments, et a l’intérieur on initialise les attributs aux valeurs des arguments de la fonctions. Du coup lorsque l’on instancie un personnage on peux préciser le nom et l’age , génial non ?

Ensuite on appelle sePresenter() et la méthode nous renvoi l’age et le prénom comme prévu, sauf que c’est ceux que l’on as précisés.

J’imagine que vous voyez l’intérêt maintenant, créons deux objets avec des valeurs différents lors de l’instanciation et appelons la méthode sePresenter() sur chacun d’eux

let michel =  new Personnage('Michel', 32); // création d'un nouveau personnage
let jacques = new Personnage('Jacques', 40);
console.log(michel.sePresenter());
console.log(jacques.sePresenter());

Ici on crée deux objets avec des valeurs différentes et on appelle la même méthode, ce qui donne :

Salut je m'appelle Michel et j'ai 32 ans
Salut je m'appelle Jacques et j'ai 40 ans

Génial non ? A partir d’un seul schéma on peux obtenir deux objets avec des valeurs différentes très facilement, vous voyez maintenant la puissance des classes ? Et croyez moi ce n’est que le début

L’héritage dans la programmation orientée objet

On va maintenant voir l’héritage. C’est une technique extrêmement utilisée en programmation.

A quoi sers t-elle exactement ? Et bien elle permets de dériver une classe à partir d’une autre. En claire on crée une classe enfant à partir d’une classe parent.

Oui je sais c’est très abstrait comme ça, prenons un exemple pour rendre tout ça plus clair.

Schéma héritage de la programmation orientée objet
Schéma héritage de la programmation orientée objet

Sur ce schéma , on voit que les classes dérivent toutes d’une classe mère , Animal. On peux imaginer que cette classe as des attributs et méthodes communs à tout les animaux. Ensuite on crée des classes enfant qui vont avoir des attributs et des méthodes supplémentaires. Ces suppléments seront adaptés aux besoin de la classe. Par exemple un animal pourras avoir des méthodes comme “reproduction” et la classe herbivore pourras posséder en plus “manger de l’herbe”. L’idée c’est de comprendre que l’on peux transmettre des méthodes d’un parent à un enfant.

Pour vous donner un exemple concret, imaginons un site web qui dois gérer des utilisateurs, on va avoir une classe Mère “utilisateur” , puis des enfants pour les grades, comme modérateur, utilisateur ou administrateur. Ces classes vont avoir une même bases de méthodes et attributs, et on va ensuite greffer ce dont on as besoin sur la classe fille.

La plupart des applications aujourd’hui utilisent la programmation orientée objet, a l’exception de langages comme Haskell ou de paradigmes comme la programmation fonctionnelle.

Et l’héritage est une composante essentielle de la programmation orientée objet. Parce qu’elle permets d’avoir une application modulaire et de créer des objets strictement adaptés à chaque besoins.

Encore une fois, c’est dépendant de chaque langage mais en temps normal on hérite d’une classe en utilisant le mot clé extends.

Par exemple :

class Personnage { // création d'une nouvelle classe Personnage

    constructor(name, age) { // méthode lancée a la création de l'objet
        this.name = name;
        this.age = age;
    }

    sePresenter() { // création d'une méthode retournant une chaine de caractère
        return `Salut je m'appelle ${this.name} et j'ai ${this.age} ans`
    }
}


class Professeur extends Personnage {
    constructor(name, age, matiere) {
        super(name, age );
        this.matiere = matiere
    }

    professeurPresentation() {
        return `Je m'appelle ${this.name} et j'enseigne ${this.matiere}`
    }
}

const marie = new Professeur('marie', 44, 'histoire géographie')
console.log(marie.sePresenter());
console.log(marie.professeurPresentation());

Alors ce code est un peu plus technique mais ça devrait aller, d’abord on crée la classe personnage. Ensuite on crée la classe professeur qui hérite de personnage.

La ça deviens un peu technique, on appelle le constructeur du parent dans le constructeur enfant. Je ne vais pas vous mentir la syntaxe change complètement d’un langage à l’autre. Vous pouvez taper “comment appeller le constructeur parent” et le nom de votre langage sur google pour obtenir la syntaxe.

L’idée c’est d’injecter les propriétés au constructeur parent pour que this.name et this.age soit assignés dans le constructeur de la classe enfant.

Une fois ça fait, on crée une nouvelle méthode et on teste notre nouvelle classe. On voit qu’elle possède les attributs parents ainsi que les méthodes parents. Et on voit aussi qu’elle peux appeler les méthodes nouvelles.

le résultat :

Salut je m'appelle marie et j'ai 44 ans
Je m'appelle marie et j'enseigne histoire géographie

Donc on as bien hérité notre nouvelle classe de l’ancienne , crée des nouvelles méthodes et conservés les anciennes. Génial non ? Bien sur il est possible de créer plusieurs classes d’une même classe mère. Ou encore d’enchaîner l’héritage sur plusieurs générations de classes.

Pourquoi utiliser la programmation orientée objet

Comme vous le voyez, la programmation orientée objet ça demande pas mal de préparation. Les possibilités sont infinis mais ça demande d’avoir un bon niveau.

On pourrais franchement se demander, pourquoi utiliser ça. Il y a certes quelques avantages mais ça fait beaucoup de complications pour pas grand chose…

Laissez moi vous convaincre du contraire grâce à quelques exemples.

Réutilisez votre code

Un des premiers avantages de la programmation orientée objet c’est que l’on peux très facilement utiliser une même classe dans plusieurs projets. Pour ça il suffit d’exporter le ou les fichiers contenant la classe et de les intégrer dans un autre projet.

Imaginons que nous créons une classe permettant de faire des requêtes à un serveur météo. Vous pourriez très bien vouloir utiliser cette classe dans différents projets.

Ou pourquoi pas une classe permettant de créer une fenêtre de jeux vidéo. Dans ce cas chaque jeux vidéo que vous aller créer pourras utiliser cette classe.

Vous le voyez la programmation orientée objet permets d’avoir du code que l’on peux réutiliser dans plusieurs projets. Si vous êtes développeurs de jeux-vidéos, ce genre de classe vous éviteras de tout coder à chaque fois.

Une simplicité d’utilisation

Au début on as l’impression que la programmation orientée objet c’est super difficile à mettre en place et à utiliser. Bien heureusement c’est faux.

La programmation orientée objet une fois que l’on as compris l’héritage et le fait de pouvoir manipuler des objets les uns avec les autres c’est très facile.

Et lorsque je dis simplicité d’utilisation, ça va plus loin que ça. Il peux être compliqué de créer une classe c’est vrai. Mais une fois crée il est facile d’utiliser les objets instanciés.

C’est vrai, notre classe Personnage s’utilise très facilement, créer un objet est facile et appeler les méthodes c’est tout aussi facile.

Modularité et combinaisons

La on rentre dans un aspect plus complexe. Il est fort probable que vous ne le compreniez pas les premières fois que vous utilisez la programmation orientée objet. Sachez qu’il est possible d’utiliser un objet dans un autre.

Pour se faire prenons un exemple très simple. Imaginons une classe guerrier qui peux avoir un attribut arme. Il peux attaquer avec son arme. Et bien sachez que l’arme peux très bien être un objet instancié depuis la classe arme.

Donc notre objet possède un objet dans ses attributs, génial non ?

Cette technique permets de créer différents niveaux de méthodes et d’attributs ce qui permets de faire des choses fantastiques. Dans le cas de notre guerrier, son arme peux avoir des pouvoirs spéciaux. Et ces pouvoirs ne seront pas stockés dans la classe Personnage mais dans la classe Arme.

Les erreurs à éviter

On va maintenant voir les erreurs communes en programmation orientée objet. Comme je l’ai dis c’est un système très puissant mais il y a beaucoup d’erreurs que l’on peux faire lorsque l’on débute. Dans cette section on va voir comment éviter de faire des erreurs bêtes.

Mauvais noms de variables

C’est une des premières erreurs que l’on peux faire. Surtout si on débute en programmation. Cette erreur ne va pas avoir d’incident direct sur votre code mais va clairement rendre le code de moins bonne qualité

En fait, mal nommer vos variables c’est la meilleure idée pour ne pas se rappeler d’a quoi sert un attribut. Si votre classe en as 10 ce n’est pas grave mais si elle hérite ou va faire hériter plusieurs centaines d’attributs ou de méthodes, difficile de se rappeler.

Utiliser des noms de variables bien descriptifs comme “profession” ou “armeEquipee” est une bonne solution, n’utilisez pas des choses comme “i” , je voit beaucoup trop de débutants commettre ces erreurs sur des forums et je vous invite à faire attention.

Hériter trop de fois

L’héritage c’est génial, mais je voit beaucoup de débutants surtout en Java qui héritent pour tout et rien. Des qu’une seule chose change ils héritent une nouvelle fois. Au lieu de ça, intégrez directement la fonctionnalité dans le parent, c’est beaucoup plus simple.

Les héritages multiples ralentissent considérablement votre code et ajoute une complexité gigantesque. La règle d’or c’est d’utiliser l’héritage seulement lorsqu’il y a un changement réel de l’objet, par exemple passer de personnage à professeur ou de personnage à guerrier.

Réécrire une méthode héritée

Alors, vous n’avez pas idée du nombre de bugs engendrés par cette petite erreur. Lorsque vous réecrivez une méthode parent dans un enfant, cette méthode va remplacer la méthode parent. Le problème c’est que lorsque les personnes héritent trop de fois, elles réecrivent souvent sans se rendre compte une méthode parent, ce qui génère des bugs difficile à trouver.

La solution c’est d’utiliser des noms de méthodes très spécifiques et de faire très attention pour ne pas causer de bugs d’héritage.

En conclusion

La programmation orientée objet c’est une des méthodes de coder si ce n’est la méthode de coder la plus utilisée au monde. Elle permets d’avoir un code simple, lisible et modulaire. Elle peux sembler complexe à prendre en main au début mais une fois habitué elle est très puissante et permets de coder plus rapidement.

Si cet article vous as plu, vous pouvez vous abonner à ma newsletter pour recevoir le guide GRATUIT Ultime pour bien débuter la programmation

Vous abonner à notre newsletter

* champ requis



Laisser un commentaire

Fermer le menu
×
×

Panier