C2.1 : Initiation à la programmation orientée objet (POO)

Mise en évidence sur un exemple

Version "programmation classique (impérative)"

On souhaite programmer le jeu suivant :

Un exemple d'affichage du déroulement d'une partie est proposé ci-dessous :

A : 50 points de vie
B : 50 points de vie
----- Nouveau tour -----
A : 48 points de vie
B : 47 points de vie
----- Nouveau tour -----
A : 39 points de vie
B : 42 points de vie
----- Nouveau tour -----
A : 35 points de vie
B : 36 points de vie
----- Nouveau tour -----
A : 28 points de vie
B : 29 points de vie
----- Nouveau tour -----
A : 26 points de vie
B : 19 points de vie
----- Nouveau tour -----
A : 16 points de vie
B : 10 points de vie
----- Nouveau tour -----
A : 8 points de vie
B : 7 points de vie
----- Nouveau tour -----
A : -2 points de vie
B : -3 points de vie
----- Fin du jeu -----
Match nul...

A faire => Écrire le programme correspondant à ces règles, les deux joueurs seront gérés par l'ordinateur.

Version "programmation orientée objet"

Généralités

Dans le programme précédant, on observe que les joueurs ont tous des caractéristiques communes :

L'idée est alors de construire une structure informatique spécifique, autrement dit, une structure de données. Cela s'appelle une classe. Le nom et les points de vie sont des attributs de cette classe. La capacité d'infliger des dégâts, la capacité de recevoir des dégâts... sont des méthodes de cette classe.

On pourra ensuite créer autant de joueurs que l'on souhaite. Les joueurs créés s'appellent des objets.

Un peu de python

Importations de la fonction randint du module random :

from random import randint

Création de la classe "Joueur" :

class Joueur:
    def __init__(self, nom):
        self.__pdv = 50
        self.__nom = nom

    def attaque(self):
        degas_infliges = randint(1,10)
        return degas_infliges

    def defense(self,degats_recus):
        self.__pdv = self.__pdv - degats_recus
        if self.__pdv <= 0 :
            self.__pdv = 0

    def get_pdv(self):
        return self.__pdv

    def get_nom(self):
        return self.__nom

Création des objets "joueurs" :

j1 = Joueur("Arthur")
j2 = Joueur("Lancelot")

Lignes de code pour le jeu :

while j1.get_pdv() > 0 and j2.get_pdv() > 0:
    j1.defense(j2.attaque())
    j2.defense(j1.attaque())
    print("----- Nouveau tour -----")
    print(j1.get_nom() + " a " + str(j1.get_pdv()) + " points de vie")
    print(j2.get_nom() + " a " + str(j2.get_pdv()) + " points de vie")

Bilan : Vocabulaire

Une structure de données est un ensemble cohérent qui permet de stocker et manipuler des informations à l'aide d'algorithmes.

Une structure de données se caractérise par :

  • - son interface : c'est l'ensemble de ce à quoi l'utilisateur de la structure de données peut accéder ;
  • - son implémentation : c'est le code utilisé pour programmer la structure de données (l'implémentation n'a pas besoin d'être connue de l'utilisateur de la structure de données).

L'utilisation des classes est une façon d'implémenter des structures de données.

Une classe a la même interface que la structure de donnée qu'elle permet d'implémenter, et se caractérise par son interface :

  • - les attributs publics ;
  • - les méthodes publiques, et en particulier le constructeur de la classe.

La définition d'une classe est l'ensemble du code qui permet de créer la classe.

Une fois la classe écrite, son utilisation consiste à définir des instances de cette classe, aussi appelées des objets.

Applications

Application n° 1

On souhaite gérer informatiquement une collection de DVD (référencement et prêts).

Proposer l'interface d'une structure de données pour les objets DVD, pour cela, lister les attributs et les méthodes de cette interface.

Application n° 2

On propose, en Python, l'implémentation suivante d'une structure de donnée pour des voitures.

class Voiture:
    def __init__(self, places):
        self.__places = places
        self.__vitesse = 0
        self.__passagers = 0

    def accelere(self):
        self.__vitesse = self.__vitesse + 10/(self.__passagers+1)

    def ralenti(self):
        self.__vitesse = self.__vitesse - 10/(self.__passagers+1)
        if self.__vitesse <= 0 :
            self.__vitesse = 0

    def ajout_passager(self):
        assert self.__passagers <= self.__places - 2, "Trop de passagers dans la voiture"
        self.__passagers = self.__passagers + 1

    def get_passager(self):
        return self.__passagers

    def get_vitesse(self):
        return self.__vitesse

1) Donner l'interface de la structure de données ainsi implémentée.

2) Dans le programme principal, écrire la suite d'instructions correspondant aux actions suivantes :