La programmation orientée objet

La programmation orientée objet est un paradigme de programmation qui consiste à représenter les concepts du domaine étudié sous forme d’objets. Un objet est une entité qui possède des attributs (des données) et des méthodes (des fonctions) qui définissent son état et son comportement.

En Python, tout est objet : les nombres, les chaînes de caractères, les listes, les fonctions, etc. On peut créer ses propres types d’objets en définissant des classes. Une classe est un modèle qui décrit les attributs et les méthodes communs à tous les objets du même type.

Par exemple, on peut créer une classe Voiture qui décrit les attributs (couleur, marque, vitesse) et les méthodes (démarrer, accélérer, freiner) communs à toutes les voitures. On peut ensuite créer des objets à partir de cette classe en utilisant le constructeur __init__ qui permet d’initialiser les attributs avec des valeurs spécifiques.

Exemple:

class Voiture: #définition de la classe Voiture
    def __init__(self,couleur,marque): #constructeur de la classe
        self.couleur = couleur #attribut couleur
        self.marque = marque #attribut marque
        self.vitesse = 0 #attribut vitesse

    def demarrer(self): #méthode démarrer
        print("La voiture démarre.")

    def accelerer(self): #méthode accélérer
        self.vitesse += 10 #augmente la vitesse de 10 km/h
        print("La voiture accélère. Sa vitesse est de " + str(self.vitesse) + " km/h.")

    def freiner(self): #méthode freiner
        self.vitesse -= 10 #diminue la vitesse de 10 km/h
        print("La voiture freine. Sa vitesse est de " + str(self.vitesse) + " km/h.")

ma_voiture = Voiture("rouge","Renault") #création d'un objet Voiture

print(ma_voiture.couleur) #affiche rouge
print(ma_voiture.marque) #affiche Renault

ma_voiture.demarrer() #affiche La voiture démarre.
ma_voiture.accelerer() #affiche La voiture accélère. Sa vitesse est de 10 km/h.
ma_voiture.freiner() #affiche La voiture freine. Sa vitesse est de 0 km/h.

L’un des principes fondamentaux de la programmation orientée objet est l’héritage. L’héritage permet à une classe de dériver d’une ou plusieurs classes parentes et d’hériter de leurs attributs et méthodes ¹ ². L’héritage permet ainsi de réutiliser du code existant, d’éviter les redondances et de faciliter la maintenance.

L’héritage simple consiste à créer une classe fille à partir d’une seule classe mère ¹ ². Par exemple, on peut créer une classe Camion qui hérite de la classe Voiture et qui ajoute un attribut (charge) et une méthode (charger) spécifiques aux camions.

Exemple:

class Camion(Voiture): #définition de la classe Camion qui hérite de Voiture
    def __init__(self,couleur,marque,charge): 
        Voiture.__init__(self,couleur,marque)

        self.charge = charge #attribut charge

    def charger(self,poids): #méthode charger
        self.charge += poids #augmente la charge du poids
        print("Le camion charge " + str(poids) + " kg. Sa charge est de
 " + str(self.charge) + " kg.")

mon_camion = Camion("blanc","Mercedes",1000) #création d'un objet Camion

print(mon_camion.couleur) #affiche blanc
print(mon_camion.marque) #affiche Mercedes
print(mon_camion.vitesse) #affiche 0

mon_camion.demarrer() #affiche La voiture démarre.
mon_camion.accelerer() #affiche La voiture accélère. Sa vitesse est de 10 km/h.
mon_camion.freiner() #affiche La voiture freine. Sa vitesse est de 0 km/h.

mon_camion.charger(500) #affiche Le camion charge 500 kg. Sa charge est de 1500 kg.

On remarque que la classe Camion hérite des attributs (couleur, marque, vitesse) et des méthodes (démarrer, accélérer, freiner) de la classe Voiture. On peut donc utiliser ces attributs et ces méthodes sur un objet Camion comme sur un objet Voiture.

On remarque aussi que la classe Camion utilise le constructeur __init__ de la classe Voiture pour initialiser les attributs communs. Pour cela, on utilise le mot-clé super qui permet d’accéder à la classe parente . On peut aussi utiliser le nom de la classe parente directement comme dans l’exemple.

L’héritage multiple consiste à créer une classe fille à partir de plusieurs classes mères . Par exemple, on peut créer une classe Hybride qui hérite des classes Voiture et Velo et qui combine leurs attributs et leurs méthodes.

Exemple:

class Velo: #définition de la classe Velo
    def __init__(self,couleur,nb_vitesses):
        self.couleur = couleur #attribut couleur
        self.nb_vitesses = nb_vitesses #attribut nombre de vitesses
        self.vitesse = 0 #attribut vitesse

    def pedaler(self): #méthode pédaler
        self.vitesse += 5

Voici un exercice sur l’héritage multiple :

Créez une classe Animal qui possède un attribut nom et une méthode parler qui affiche le nom de l’animal et le son qu’il fait.

Créez deux classes Chien et Chat qui héritent de la classe Animal et qui redéfinissent la méthode parler pour afficher respectivement “ouaf” et “miaou”.

Créez une classe ChienChat qui hérite des classes Chien et Chat et qui redéfinit la méthode parler pour afficher les deux sons.

Créez un objet de la classe ChienChat et appelez la méthode parler .

class Animal: #définition de la classe Animal
    def __init__(self,nom): #constructeur de la classe
        self.nom = nom #attribut nom

    def parler(self): #méthode parler
        print(self.nom + " fait du bruit.")

class Chien(Animal): #définition de la classe Chien qui hérite de Animal
    def parler(self): #méthode parler redéfinie
        print(self.nom + " fait ouaf.")

class Chat(Animal): #définition de la classe Chat qui hérite de Animal
    def parler(self): #méthode parler redéfinie
        print(self.nom + " fait miaou.")

class ChienChat(Chien,Chat): #définition de la classe ChienChat qui hérite de Chien et Chat
    def parler(self): #méthode parler redéfinie
        print(self.nom + " fait ouaf et miaou.")

mon_chien_chat = ChienChat("Rex") #création d'un objet ChienChat

mon_chien_chat.parler() #affiche Rex fait ouaf et miaou.

L’héritage est un concept fondamental de la programmation orientée objet qui permet de créer des classes dérivées à partir de classes existantes. L’héritage simple consiste à créer une classe fille qui hérite d’une seule classe mère. L’héritage multiple consiste à créer une classe fille qui hérite de plusieurs classes mères. L’héritage permet de réutiliser le code, d’éviter la redondance et de faciliter la maintenance. Il faut cependant faire attention aux conflits de noms et à l’ordre de résolution des méthodes en cas d’héritage multiple.