INTRODUCTION

Vous avez déjà pu vous familiariser avec les notions essentielles de la programmation orientée objets (POO) et compris qu’il serait très difficile de développer un jeu vidéo en Python sans recourir à cette technique. Il est de ce fait capital de continuer à comprendre ces notions ainsi que leur implémentation en Python de manière plus systématique.

VARIABLES D’INSTANCE

Les animaux se prêtent bien à être représentés par des objets. On commence par définir une classe Animal qui affiche l’image de l’animal approprié dans l’arrière-fond de la fenêtre de jeu. Lors de la construction d’une instance de cette classe, on spécifie au constructeur le chemin vers le fichier image à utiliser de sorte que le méthode showMe() soit capable d’afficher l’image grâce aux méthodes de dessin de la classe GGBackground.

Les animaux se prêtent bien à être représentés par des objets. On commence par définir une classe Animal qui affiche l’image de l’animal approprié dans l’arrière-fond de la fenêtre de jeu. Lors de la construction d’une instance de cette classe, on spécifie au constructeur le chemin vers le fichier image à utiliser de sorte que le méthode showMe() soit capable d’afficher l’image grâce aux méthodes de dessin de la classe GGBackground. Le constructeur qui reçoit ce chemin vers le fichier image doit le sauver dans une variable de sorte que toutes les autres méthodes de la classe puissent y avoir accès ultérieurement. Une telle variable est un attribut d’instance ou variable d’instance. En Python, les variables d’instance sont préfixées au sein des objets par self et sont créées en mémoire lorsqu’on leur affecte pour la première fois une valeur. Comme nous l’avons déjà mentionné, le constructeur porte le nom spécial __init__(avec deux caractères de soulignement « underscore » avant et après). Aussi bien le constructeur que les méthodes de la classe doivent impérativement être définis avec self comme premier paramètre formel, sans quoi des erreurs apparaîtront lors de leur utilisation.

On commence donc par définir le constructeur comme suit : def __init__(self, imgPath: de même qu’une méthode  def showMe(self, x, y: Une fois que l’on a créé un objet myAnimal avec myAnimal = Animal(bildpfad) Une fois que l’on a créé un objet myAnimal avec myAnimal.showMe(x, y)

Il est particulièrement indiqué de recourir à la POO lorsque l’on utilise plusieurs objets de la même classe. Pour bien mettre ceci en évidence, le programme ci-dessous fait apparaitre un nouvel animal lors de chaque clic de souris.

from gamegrid import *

# ---------------- class Animal ----------------
class Animal():
    def __init__(self, imgPath):
        self.imagePath = imgPath  # Instance variable
    def showMe(self, x, y):  # Method definition
         bg.drawImage(self.imagePath, x, y) 

def pressCallback(e):
    myAnimal = Animal("sprites/animal.gif") # Object creation
    myAnimal.showMe(e.getX(), e.getY())  # Method call

makeGameGrid(600, 600, 1, False, mousePressed = pressCallback)
setBgColor(Color.green)
show()
doRun()
bg = getBg()

MEMENTO

HÉRITAGE, AJOUT DE MÉTHODES

Les hiérarchies de classes sont créées par dérivation de classes ou héritage, ce qui permet d’ajouter à une classe existante de nouvelles méthodes et attributs. Les instances de la classe dérivée sont également considérées des instances de la classe parente (également appelée classe de base ou super classe) et peuvent de ce fait utiliser toutes les méthodes et attributs de la classe parente. Du point de vue de la classe dérivée, c’est comme si ces méthodes ou attributs hérités étaient directement définis dans la classe dérivée elle-même.

Concrètement, un animal de compagnie possède tous les attributs et comportements d’un animal mais dispose en plus d’un nom qu’il peut afficher avec la méthode tell(). De ce fait, on définit une classe Pet (Animal de compagnie) dérivée de la classe Animal. Comme on veut pouvoir spécifier le nom de chaque animal de compagnie individuellement lors de sa création, on équipe le constructeur d’un paramètre formel supplémentaire name servant à initialiser la variable d’instance self.name propre à chaque animal de compagnie.

from gamegrid import *
from java.awt import Point

# ---------------- class Animal ----------------
class Animal():
    def __init__(self, imgPath): 
        self.imagePath = imgPath 
    def showMe(self, x, y): 
         bg.drawImage(self.imagePath, x, y)

# ---------------- class Pet ----------------
class Pet(Animal):   # Derived from Animal
    def __init__(self, imgPath, name):  
        self.imagePath = imgPath 
        self.name = name
    def tell(self, x, y): # Additional method
        bg.drawText(self.name, Point(x, y))

makeGameGrid(600, 600, 1, False)
setBgColor(Color.green)
show()
doRun()
bg = getBg()
bg.setPaintColor(Color.black)

for i in range(5):
    myPet = Pet("sprites/pet.gif", "Trixi")
    myPet.showMe(50 + 100 * i, 100) 
    myPet.tell(72 + 100 * i, 145)

MEMENTO

HIÉRARCHIE DE CLASSES, REDÉFINITION DE MÉTHODES

MEMENTO

POLYMORPHISME: APPEL DE MÉTHODES DIRIGÉE PAR LE TYPE

Le polymorphisme est un peu plus ardu à comprendre mais il constitue une fonctionnalité essentielle de la programmation orientée objets. Il concerne l’appel des fonctions redéfinies (overridden methods) dans les classes dérivées en adaptant l’appel en fonction de la classe à laquelle l’instance est affiliée. Voici un exemple qui permettra de clarifier cette notion : un programme définit une liste Animals contenant des instances d’animaux de compagnie de types différents  

animals = [Dog(), Dog(), Cat()]

Le fait de parcourir cette liste et d’invoquer la méthode tell() poserait problème sans le polymorphisme car il y a trois méthodes différentes nommées tell() parmi les classes Pet, Dog et Cat. 

for animal in animals:
    animal.tell()

from gamegrid import *
from soundsystem import *

# ---------------- class Animal ----------------
class Animal():
    def __init__(self, imgPath): 
        self.imagePath = imgPath 
    def showMe(self, x, y):  
         bg.drawImage(self.imagePath, x, y) 
         
# ---------------- class Pet ----------------
class Pet(Animal): 
    def __init__(self, imgPath, name): 
        Animal.__init__(self, imgPath) 
        self.name = name
    def tell(self, x, y):
        bg.drawText(self.name, Point(x, y))

# ---------------- class Dog ----------------
class Dog(Pet):
    def __init__(self, imgPath, name): 
         Pet.__init__(self, imgPath, name)  
    def tell(self, x, y): # Overridden
         Pet.tell(self, x, y)
         openSoundPlayer("wav/dog.wav")
         play()

# ---------------- class Cat ----------------
class Cat(Pet):
    def __init__(self, imgPath, name):
        Pet.__init__(self, imgPath, name) 
    def tell(self, x, y): # Overridden
        Pet.tell(self, x, y)
        openSoundPlayer("wav/cat.wav")
        play()

makeGameGrid(600, 600, 1, False)
setBgColor(Color.green)
show()
doRun()
bg = getBg()

animals = [Dog("sprites/dog.gif", "Alex"), 
     Dog("sprites/dog.gif", "Rex"), 
     Cat("sprites/cat.gif", "Xara")]

y = 100
for animal in animals:
    animal.showMe(100, y)     
    animal.tell(200, y + 30)    # Which tell()???? 
    show()
    y = y + 200
    delay(1000)

MEMENTO

EXERCICES

MATÉRIEL SUPPLÉMENTAIRE

VARIABLES ET MÉTHODES STATIQUES

Les classes peuvent également être utilisées pour regrouper des variables et fonctions qui ont un but commun dans le but de rendre le code plus lisible. On pourrait par exemple regrouper les principales constantes physiques dans la classe Physics. Des variables définies directement sous l’en-tête de la classe sont appelées variables statiques et on s’y réfère en préfixant leur nom de celui de la classe dont elles font partie. Au contraire des variables d’instance, il n’est pas nécessaire de créer une instance de la classe pour y accéder.

import math

# ---------------- class Physics ----------------
class Physics():
    # Avagadro constant [mol-1]
    N_AVAGADRO = 6.0221419947e23
    # Boltzmann constant [J K-1]
    K_BOLTZMANN = 1.380650324e-23
    # Planck constant [J s]
    H_PLANCK = 6.6260687652e-34;
    # Speed of light in vacuo [m s-1]
    C_LIGHT = 2.99792458e8
    # Molar gas constant [K-1 mol-1]
    R_GAS = 8.31447215
    # Faraday constant [C mol-1]
    F_FARADAY = 9.6485341539e4;
    # Absolute zero [Celsius]
    T_ABS = -273.15
    # Charge on the electron [C]
    Q_ELECTRON = -1.60217646263e-19
    # Electrical permittivity of free space [F m-1]
    EPSILON_0 = 8.854187817e-12
    # Magnetic permeability of free space [ 4p10-7 H m-1 (N A-2)]
    MU_0 = math.pi*4.0e-7

c = 1 / math.sqrt(Physics.EPSILON_0 * Physics.MU_0)
print("Speed of light (calulated): %s m/s" %c)
print("Speed of light (table): %s  m/s" %Physics.C_LIGHT)

On peut également regrouper des fonctions apparentées en les déclarant comme statiques dans une même classe. On peut ensuite utiliser ces méthodes en préfixant leur nom par celui de leur classe sans avoir à créer une instance de cette classe .

Pour déclarer une méthode comme statique, il faut écrire la ligne @staticmethod juste au-dessus de sa définition.

# ---------------- class OhmsLaw ----------------
class OhmsLaw():
    @staticmethod
    def U(R, I):
        return R * I

    @staticmethod
    def I(U, R):
        return U / R
    
    @staticmethod
    def R(U, I):
        return U / I

r = 10
i = 1.5

u = OhmsLaw.U(r, i)
print("Voltage = %s V" %u)

MEMENTO