Histoire de la programmation objet

Struct

• LISP : en plus des listes, des objets avec des champs/attributs 1960s

Objet

• ALGOL W en 1966 : C. A. R. Hoare, champs/attributs et méthodes, mais pas de constructeurs
• Simula 67 par Ole-Johan Dahl and Kristen Nygaard in Norway :
  • constructeur

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def norm():
        return sqrt(self.x ** 2 + self.y ** 2)

p = Point(2, 3)
q = Point(0, 1)
print(p.norm())

class Graph:
    def __init__(self, n: int):
        self.nbVertices = n
        self.adjList: list[list[int]] = [[] for _ in range(n)]
    
    def addEdge(self, u:int, v:int):
        self.adjList[u].append(v)
        
    def neighbors(self, v: int) -> list[int]:
        return self.adjList[v]

Encapsulation

L’ encapsulation a deux sens : le fait d’avoir les données et les méthodes. Mais aussi de cacher des champs aux utilisateurs.

• Simula 67 :
  • naissances des champs privés et publics (privés = “hidden”)

En Python, mettre __ devant le nom de champs et il est privé.

• Simula 67
  • héritage
  • méthodes virtuelles

Apparté Python

[[]] * n VS [[] for _ in range(n)] * 3

Vision d’Alan Kay

Smalltalk 1970

• Encapsulation
• Message passing
• Liaison dynamique ~ Duck typing

class Cat:
    def speak(self):
        print("miaou")

class Dog:
    def speak(self):
        print("waouf")

L: list[Cat | Dog] = [Cat(), Dog(), Cat(), Cat()]

for animal in L:
    animal.speak()

• isinstance(objet, class)

Héritage

Tout coder (sans type paramétrées)

Itérateur

• Objet itérable : liste, etc.

• Itérateur

• Générateur

• CLU (for “CLUsters”) par Barbara Liskov en 1973 :

  • types abstraits
  • itérateurs

Types paramétrées (polymorphisme de type)

• types paramétrées (e.g List[T])
• types somme (e.g. List[T] | None)
• pas d’héritage (!)

Finir l’implémentation

Exemple de patron de conception

• Tableaunoir : patron de conception Command