English

Programmation orientée objet

Le paradigme OOP voit le programme comme un ensemble d'objets qui interagissent entre eux.

Classes, objets et héritage

Chaque object est défini par une classe qui elle même hériter d'autres classes ou interfaces.
Une classes peut définir des propriétés et des méthodes, qu'on appelle des membres.
- Propriété : une vue sur une donnée via ses accesseurs en lecture et / ou écriture (qu'on appelle getters et setter respectivement).
- Méthode : fonction qui est définie au sein de la classe
- Constructeur: méthode particulière qui sera appelée automatiquement au moment de la création de l'instance
En python, le premier argument des méthodes et du constructeur est une référence vers l'objet actuel
- Le nom de cet argument doit s'appeler self (appelé this dans d'autres langages)
- On appelle self le contexte de la méthode
Une classe enfant peut hériter d'une classe parente:
- Dans ce cas, la classe enfant contiendra implicitement tous les membres de la classe mère
- La classe enfant peut définir des membres supplémentaires qui lui seront propres
- La classe enfant peut redéfinir des membres de classe parent. On appelle cela une surcharge ou override en Anglais.
Python est l'un des rares langages (avec le C++) à permettre l'héritage multiple. i.e. une classe peut hériter de plusieurs classes à la fois.

class Rectangle:
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return (self.width + self.height) * 2

    def __str__(self):
        return f"x: {self.x}, ..."


r = Rectangle(10, 1, 100, 5)
print(r)

class Person:
    # constructeur
    # self est l'équivalent du this dans les autres langages
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_name(self):
        print(self.name)

    def __str__(self):
        return f"Person: {self.name} - {self.age}"


class Student(Person):
    def __init__(self, num_student, name, age):
        self.num_student = num_student
        # appel du constrcteur parent
        super().__init__(name, age)

    def __str__(self):
        return f"Student {self.num_student}, Parent __str__:" + super().__str__()


pDico = {"name": "dfsdfs", "age": 230}

p1 = Person("John", 36)

print(p1.name)
print(p1.age)
p1.age = 10
p1.say_name()
print(p1, pDico)

s = Student("2323JFLSJ", "A", 19)
print(s)

Notions de statique et abstrait

Notion de Propriété, méthode ou classe statique:
- Propriété d'instance : chaque instance a ses propres proriétés d'instances
- Propriété statique : elle sera partagée entre toutes les instances (comme une variable globale pour la classe)
- Méthode d'instance : sera exécutée dans le contexte de l'instance qui l'a appelée (accessible via self)
- Méthode statique : méthode qui a comme contexte que les propriété et méthodes statiques de sa classe
- Classe statique : une classe qui ne peut pas être instanciée et ne contiendra donc que des propriété et méthodes statiques
Méthode, propriété et classe abstraite:
- Méthode abstraite: méthode qui n'a pas d'implémentation
- Propriété abstraite: propriété dont les accesseurs ne sont pas définis
- Classe abstraite: une classe qui a au moins une propriété ou méthode abstraite
- Les membres abstraits sont destinés à être définis par une sous classe non abstraite.