La programmation Objet

Introduction

La programmation objet est une façon de programmer permettant de matérialiser informatiquement des objets de notre univers, par le biais d'attributs et méthodes.
En programmation objet, un attribut correspond à une propriété définissant un objet. On peut donc avoir plusieurs attributs, si l'objet a plusieurs propriétés qui le caractérisent. Les méthodes sont des ensembles de fonction à définir permettant d'interagir directement avec notre objet, pour y modifier ses attributs.

Exemple avec une voiture :

Une voiture est caractérisée par diverses propriétés :

• Une couleur (modifiable)
• Une marque
• Un type de carburant
• Un modèle
• Un kilométrage
• etc ...

Les méthodes vont servir à interagir avec ces propriétés. La fonction rouler(km) pourra par exemple augmenter le kilométrage de la voiture.

Initialisation en python

Un objet en programmation est appelé class. La création d'un objet consiste à définir sa classe avec le mot-clé class, suivi du nom correspondant à l'objet qu'elle doit matérialiser. Elle représente un modèle sur lequel les objets se basent :

class Voiture :
    #tout ce qui est indenté ici fera partie intégrante de la class

Par la suite, un objet a besoin d'être construit, grâce à une méthode spéciale et obligatoire (appelée constructeur) :

class Voiture :
    def __init__(self):
        print("Voiture construite !")

Attention

La fonction __init__ s'écrit avec 2 _ de chaque côté, et prend obligatoirement self en paramètre. On peut évidemment mettre d'autres paramètres après le self.

Self

C'est un mot-clé permettant de qualifier l'objet en question dans une classe, ou lorsqu'une méthode est appelée. On n'utilise self que dans une classe.
Self correspond à un objet créé, qui possède des attributs et permet d'appeler des méthodes dans d'autres méthodes de la classe.

Quand le constructeur est écrit, on peut créer des instances de la classe dans le main, en appelant le nom de la classe, et en précisant les paramètres s'il y en a :

class Voiture :
    def __init__(self):
        print("Voiture construite !")

v1 = Voiture() # Affiche "Voiture construite !"
v2 = Voiture() # Affiche "Voiture construite !"

Et avec des paramètres, on sauvegarde chaque paramètres dans des variables associées à l'objet construit (attributs) :

class Voiture :
    def __init__(self, couleur, marque):
        self.couleur = couleur #On crée l'attribut "couleur" que l'on enregistre dans notre objet, et on lui met le paramètre "couleur"
        self.marque = marque #On crée l'attribut "marque" que l'on enregistre dans notre objet, et on lui met le paramètre "marque"
        print(self.couleur, self.marque) #On affiche ce qui est enregistré dans l'attribut "couleur" et "marque"

v1 = Voiture("Rouge","Peugeot") # On donne les valeurs en paramètre correspondant aux paramètres du constructeur
v2 = Voiture("Noir", "Renault") #Idem

Méthodes

Quand notre classe est définie avec son constructeur, on peut créer dans la classe des méthodes permettant d'interagir avec l'ensemble des attributs, ou d'autres éléments. Les méthodes s'écrivent de la même façon qu'une fonction classique, mais on doit spécifier self à nouveau en premier paramètre, sinon on ne peut pas accéder aux attributs (ou autres méthodes) :

class Voiture :
    def __init__(self, couleur, marque):
        self.couleur = couleur
        self.marque = marque
        
    def affichage(self):
        print(self.couleur, self.marque)

v1 = Voiture("Rouge","Peugeot")
v2 = Voiture("Noir", "Renault")
v1.affichage() #Affiche "Rouge" et "Peugeot"
v2.affichage() #Affiche "Noir" et "Renault"

Dans le main, on appelle les méthodes (et les attributs également) en spécifiant la variable de l'objet, suivi d'un point. Le point indique que l'on souhaite utiliser un élément stocké dans notre objet, donc méthodes, ou attributs.

Getter/Setter

Une des règles de la Programmation Orientée Objet est de ne pas pouvoir modifier à notre guise les attributs d'un objet, dans le main, ou fonctions. Pour garder le contrôle des valeurs que l'on utilise, et rendre le code plus propre, on utilise ce qui s'appelle des getter et setter.

Getter

Un getter est une méthode d'une classe permettant de retourner la valeur de l'attribut associé à la fonction. En théorie, il faudrait un getter pour chaque attribut d'une classe.

class Voiture :
    def __init__(self, couleur, marque):
        self.couleur = couleur
        self.marque = marque

    def getCouleur(self) :
        return self.couleur
    def getMarque(self) :
        return self.marque

v1 = Voiture("Rouge","Peugeot")
v2 = Voiture("Noir", "Renault")
print(v1.getCouleur()) #retourne et affiche "Rouge"
print(v2.getMarque()) #retourne et affiche "Renault

Setter

A contrario du getter, le setter va quant à lui affecter une nouvelle valeur à l'attribut dont la méthode va dépendre. Ce mode de fonctionnement permet de contrôler les valeurs, et ainsi ne pas saisir n'importe quoi :

class Voiture :
    def __init__(self, couleur, marque):
        self.couleur = couleur
        self.marque = marque

    def setCouleur(self, nouvelleCouleur) :
        ensembleCouleur = ["Rouge","Noir","Blanc","Gris"]
        if nouvelleCouleur in ensembleCouleur :
            self.couleur = nouvelleCouleur
        else :
            print("La couleur n'est pas disponible")
    def getCouleur(self) :
        return self.couleur
    def getMarque(self) :
        return self.marque

v1 = Voiture("Rouge","Peugeot")
v1.setCouleur("Blanc")
print(v1.getCouleur()) #retourne et affiche "Blanc"
v1.setCouleur("Bleu") #Affiche "La couleur n'est pas disponible"
print(v1.getCouleur()) #retourne et affiche "Blanc"

Exemple de classe : un carré

Un carré est composé d'une longueur x, qui existe 4 fois (avec un angle de 90°). On pourrait avoir une classe carré, qui permet de créer des carrés, et de calculer leur périmètre, ou leur aire, par exemple :

class carre :
    def __init__(self, x):
        self.cote = x

    def affichage(self):
        print("côté de longueur ", self.cote)

    def aire(self):
        return self.cote * self.cote

    def perimetre(self):
        return self.cote * 4

c1 = carre(3)
print(c1.aire()) #renvoie 3*3 = 9
print(c1.perimetre()) #renvoie 3*4 = 12
c2 = carre(5)
print(c2.aire()) #renvoie 5*5 = 25
print(c2.cote) #affiche 5

Dans cet exemple, on crée 2 objets de type carre, dont la variable cote de c1 vaut 3, et celle de c2 vaut 5.
Lors de l'appelle aux méthodes aire et perimetre depuis c1, dans la classe self est remplacé par c1. Ainsi self.cote devient c1.cote.