Classe (programmation)
En informatique, une classe est la description d'un objet. Les classes sont utilisées en Programmation orientée objet, et s'inspirent de la vie courante. La classe décrit l'objet physiquement (aspect) avec des variables et ce qu'il peut faire (comportement) avec des fonctions. Prenons l'exemple d'une voiture : Décrivons son aspect. C'est une Ferrari, rouge, avec des sièges en cuir. Décrivons maintenant son comportement. Elle peut démarrer, accélérer, freiner, couper le moteur... etc. On peut instancier plusieurs objets de cette classe : il existe dans le monde plusieurs voitures, plusieurs Ferrari, dont certaines sont rouges, il existe plusieurs voitures Ferrari rouges avec des sièges en cuir. Elles sont identiques en apparence, mais ce sont bien plusieurs objets distincts.
Voici un exemple de classe de voiture en Python.
class Voiture(object): # object signifie que la classe n'a pas de parent (elle ne dérive d'aucune classe existante), hormis la classe la plus fondamentale : object
def __init__(self,marque,couleur,sieges): # la fonction __init__ s'exécutera lorsqu'un objet de la classe sera instancié. Elle prend des paramètres d'aspect
self.marque = marque # On déclare que l'objet instancié a la marque précisée (cette variable spécifique à l'objet est appelée attribut)
self.couleur = couleur # idem pour la couleur
self.sieges = sieges # idem pour les sièges
self.vitesse = 0 # Lorsque la voiture est créée, elle est arrêtée (elle n'a pas de vitesse)
self.allumee = False # et son moteur est éteint (False signifie Faux)
def tourner_cle(self): # On définit la première fonction, qui ne prend aucun paramètre (hormis "self" qui représente l'objet (unique) qui réalise l'action)
if self.allumee == False: #
self.allumee = True # Le moteur s'allumes'il est éteint (True signifie Vrai)
else: #
self.allumee = False # Et il s'éteint s'il est allumé
def accelerer(self,v): # On définit une autre fonction, pour accélérer, qui prend comme paramètre une vitesse (combien de km/h la voiture va gagner)
if self.allumee == True: # On vérifie que la voiture est allumée (sinon il ne se passe rien)
self.vitesse = self.vitesse + v # On augmente la vitesse
def freiner(self,v): # On définit une autre fonction, pour freiner, qui prend comme paramètre une vitesse (combien de km/h la voiture va perdre)
self.vitesse = self.vitesse - v # La vitesse diminue (même si le moteur est éteint)
if self.vitesse < 0: # Si la vitesse est négative (par exemple si on a freiné de {{unité|100|km/h}} alors qu'on était à {{unité|50|km/h}}),
self.vitesse = 0 # c'est que la voiture a assez freiné, donc elle est à l'arrêt
voiture1 = Voiture("Ferrari","Rouge","Cuir") # Instanciation d'une voiture
voiture2 = Voiture("Peugeot","Bleu","Cuir") # Instanciation d'une voiture différente
voiture3 = Voiture("Ferrari","Rouge","Cuir") # Instanciation d'une voiture identique à la première, en aspect. C'est un object bien distinct (leurs vitesses peuvent être différentes)
voiture1.tourner_cle() # On démarre la voiture 1
voiture1.accelerer(10) # On augmente la vitesse de {{unité|10|km/h}}
print(voiture1.vitesse) # Cela affichera la vitesse de la voiture 1 : 10 (km/h)
print(voiture3.vitesse) # Cela affichera la vitesse de la voiture 3 : 0. Elle est bien différente de celle de la voiture 1, car c'est un autre objet (elle n'a pas démarré, ni accéléré)
voiture2.accelerer(100) # La voiture n'accélerera pas car elle n'a pas démarré
Précisions
Classes dérivées[modifier | modifier le wikicode]
Une classe dérivée d'une autre classe signifie qu'elle hérite des attributs et méthodes de la classe (appelée classe parente). Prenons par exemple un taxi, qui est une sorte de voiture (tous les taxis sont des voitures). Le taxi peut démarrer, accélérer, freiner, couper le moteur, mais en plus, il peut aussi prendre un passager et déposer un passager. Il est forcément de couleur jaune mais peut prendre différentes marques. Il a aussi un attribut argent, et plein (s'il contient un passager).
Voici le résultat de l'implémentation en Python (Ce code suit le précédent, sinon il ne fonctionne pas)
class Taxi(Voiture): # La classe Taxi est dérivée de la classe Voiture
def __init__(self,marque,sieges): # L'instanciation d'un taxi ne demande pas la couleur, car il est forcément jaune
Voiture.__init__(self,marque,"jaune",sieges) # Initialisation de la classe parente, avec la marque et les sièges passés à l'instanciation, et la couleur jaune
# Si l'on ajoute ici la commande "print(self.marque, self.couleur, self.sieges)", on verra que la marque et les sieges ont les
# valeurs passées à l'instanciation de l'objet, et que la couleur est jaune. (de même, allumee a la valeur False et vitesse est à 0)
self.argent = 0 # Le taxi n'a pas encore d'argent
self.plein = False # Le taxi n'a pas encore de passager
# On n'a pas besoin de repréciser les méthodes accélérer, freiner... puisqu'elles sont déjà définies dans la classe parente
def prendre_passager(self):
if self.plein == False and self.vitesse == 0 : # Si le taxi est vide et à l'arrêt
self.plein = True # alors il se remplit
def deposer_passager(self):
if self.plein == True and self.vitesse == 0 : # Si le taxi est plein et à l'arrêt
self.plein = False # alors il se vide
self.argent = self.argent + 10 # et il gagne de l'argent
taxi1 = Taxi("Renault","velours") # Instancions un taxi (on ne précise pas la couleur, car Taxi s'initialise sans argument de couleur car il la précise lui-même)
taxi1.tourner_cle() # Notre taxi peut démarrer comme toutes les voitures
taxi1.prendre_passager() # Mais il peut aussi agir comme un taxi
taxi1.accelerer(50) # Faisons une petite course
taxi1.freiner(50) #
taxi1.deposer_passager() # déposons le passager
print(taxi1.argent) # Cela affichera "10"
Précision
Classes dérivées de classes dérivées[modifier | modifier le wikicode]
Des classes peuvent être dérivées de classes déjà dérivées, elles hériteront alors des attributs et méthodes de la classe parente, et de ceux de la classe parente de la classe parente (la classe grand-parente en quelque sorte). Prenons un autre exemple. On pourrait créer une classe Animal.
class Animal(object): # La classe Animal ne dérive d'aucune autre classe
def __init__(self, nom): # méthode d'initialisation
self.nom = nom # Voici l'attribut nom
def vivre(self): # La méthode vivre
print("Je suis vivant") # On affiche "Je suis vivant"
mon_poisson_rouge = Animal("Bubulle") # Exemple d'instanciation
mon_poisson_rouge.vivre() # "Je suis vivant"
On peut ensuite créer une classe Mammifere dérivée de la classe Animal (tous les mammifères sont des animaux, cependant il y a des animaux qui ne sont pas des mammifères (oiseaux, poissons, reptiles...))
class Mammifere(Animal): # La classe Mammifere dérive de la classe Animal
def __init__(self, nom):
Animal.__init__(self, nom) # Initialisation de la classe parente
def allaiter(self): # Les mammifères peuvent allaiter leur petits
print("J'allaite mes petits") # On affiche "J'allaite mes petits"
mon_chien = Mammifere("Médor") # Exemple d'instanciation
mon_chien.vivre() # "Je suis vivant"
mon_chien.allaiter() # "J'allaite mes petits"
Dans les mammifères, il y a par exemple les Félins. Créons une classe Felin.
class Felin(Mammifere)): # La classe Felin dérive de la classe Mammifere
def __init__(self, nom):
Mammifere.__init__(self, nom) # Initialisation de la classe parente
def griffer(self): # Les félins peuvent griffer
print("Je griffe") # On affiche "Je griffe"
mon_tigre = Felin("Tigrou") # Exemple d'instanciation
mon_tigre.vivre() # "Je suis vivant"
mon_tigre.allaiter() # "J'allaite mes petits"
mon_tigre.griffer() # "Je griffe"
Dans les félins, il y a par exemple les Chats, créons une classe Chat.
class Chat(Felin): # La classe Chat dérive de la classe Felin
def __init__(self, nom):
Felin.__init__(self, nom) # Initialisation de la classe parente
def miauler(self): # Les chats peuvent miauler
print("Miaou") # On affiche "Miaou"
mon_chat = Chat("Chipette") # Exemple d'instanciation
mon_chat.vivre() # "Je suis vivant"
mon_chat.allaiter() # "J'allaite mes petits"
mon_chat.griffer() # "Je griffe"
mon_chat.miauler # "Miaou"
On voit que les Chats héritent des attributs et méthodes de toutes les classes "ancêtres", c'est-à-dire Félin, Mammifère et Animal.
|
|
- ↑ Dans les fonctions (appelées méthodes quand elles sont dans une classe), le paramètre (appelé argument) "self" sera remplacé par "voiture1" ou "voiture2" par exemple. On peut appeler une méthode depuis l'intérieur de la classe, dans ce cas là on écrira "self.methode()" car on ne connait pas le nom de l'objet qui l'exécute, puisqu'on parle en général.
Notez que les arguments de la fonction __init__ sont passés lors de l'instanciation (Voiture("Ferrari","Rouge","Cuir")) - ↑ Notez que les voitures classiques n'ont pas accès aux attributs et méthodes du taxi, car ce ne sont pas des taxis. Cependant, un taxi est toujours une voiture, donc il a les attributs et méthodes d'une voiture.
On pourrait aussi définir une classe Camion dérivée de la classe voiture (par exemple), et cette classe aurait eu accès aux attributs et méthodes de Voiture, mais pas de Taxi. Taxi n'aurait pas non plus eu accès aux attributs et méthodes de Camion.