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.