---
title: ING1 - MOB1
tags: EPITA
---

# Approche Objet de la Programmation - MOB 1

## Programmation Procédurale / Impérative

* Modèle de **Von Neumann** :
- Manipulation registre
- Echange avec la mémoire

* Programmation Impérative "pure" (FORTRAN, Assembleur)
* Origine
* Fonctionnement du matériel
* Architecture de Von Neumann
- Execution d'instruction (ordonnée)
- Effet de bord (modification de context)
Modication de l'état général du programme suite à l'exécution d'une instruction

* Programmation Procédurale "extension" (C, Python)
- Factorisation (ajout des boucles for/while,...)
- Evite la duplication de code

Approche **Bottom-Up**

### Limite prog procédurale

- Notion de paradigme
- Expressivité
- Manière de penser
**=> Peut-on exprimer X facilement ?**

- Turing-Complétude : Même puissance d'expression tous langages confondus.
- POO (Programmation Orientée Objet):
- Convergence d'état (relation plusieurs à un)
- Divergence de comportement (relation un à plusieurs)

## Principe de substitution de Liskov
Principe de substituabilité appliqué aux objets : un objet de type T est attendu, on doit pouvoir passer un objet de type Y sans que le comportement dudit objet soit changé. C'est-à-dire que tout invariant inhérent à la classe T être respecté dans ses classes filles.

## Programmation Orienté Objet

/!\ Programmation Orientée Objet => 'Message Oriented Programming' (Alan Kay)

Langage statiquement typé : opération éventuellement autorisées : introspection + instanciation

- Classe : Défini un objet
- Se comporte comme un type de données
- Nom : Type de l'objet (Human, string)
- Attribut de classe : attribut ayant la même valeur dans tous les objets d'une classe
- Méthodes de classe : méthode n'accédant qu'à des attributs de classe
- Méthode virtuelle : méthode sujette à la ré-écriture
- Méthodes qui rend l'instance dynamique (créée, modifiée, détruite)
- Instanciation : Création d'un objet (avec paramètre)
Pas de valeurs de retour
Cohérence interne (agrégats)
Si pas de constructeur fournit : langage fournit un constructeur par défaut
- Destruction (~Nom pour le C++) : Nom de la procédure prédéfinie
Destructeur = procédure de suppression d'un objet
Nettoyage mémoire
Pas de valeur de retour
Finaliseur (ramasse-miette (recyclage) : Java : Convention : .die(), .close()...)
- Relations (type static, contenu dynamique)
- Agrégation : forme d'inclusion - Relation de **type "a un"**
Maintient de références (aka pointeurs) vers des objets *agrégés*
*agréga : Human | agrégé : Employee*
Agrégé survit si l'agréga est détruit (il faut le détruire manuellement)
-> Agrégation composite : L'agrégé est détruit si son unique agréga est détruit
Relation "ensemble/parties" (transitive)
- Héritage : dérivation - Inclusion stricte - Relation de **type "est un"**
- Dérivation : héritage d'implémentation + interface
* Opération d'instanciation
* Contenu agrégé intégré dans la classe (Employee c Human)
* Pas d'agrégat (intermediaire) => Forme de sous-typage (principe de **substitution de Liskov**)
* Pas de duplication (système auto)
* Employee hérite/dérive de human
*Suite après la description de l'objet*
- Composition : Agrégation plus forte
- Objet => Instance d'une unique classe (dynamique)
- On peut générer autant d'objet que l'on veut depuis une classe
- Nom (statique) : fournit par défaut pour la création et la destruction
- Attributs (statique)
- 1 déclaration par classe (statique)
Commun à tous les objets de la classe
- Champs publique : Accès libre
- Interface : Ensemble des infos publiques
- 1 valeur par objet (dynamique)
- Champs privés : Nécessite l'instanciation d'un objet + méthode déclarée dans la classe
- Accesseurs (getter/setter) : Consultation / Modification des attributs privés
- Possibilité d'accès par concept d'amitié entre les classes (cas par cas): Cas par défaut définit
- Relation (dynamique)
- Methodes (statique)
- 1 définition par classe (statique)
- contenu spécifique à chaque objet
- Méthodes privées : accessible uniquement depuis l'intérieur de la classe

La classe qui défini l'objet est statique : fixé et connu à la compilation
API introspection (Java)
Pas d'intercession (auto-modification)

Héritage :
-
- Hiérarchie de classe :
- Relation transitive : si une classe A hérite d'une classe B qui hérite d'une classe C, alors la classe A hérite de la classe C.
- Héritage multiple : plusieurs super classes
- Structure en arbre ou en graphe orienté
- Restriction d'instanciation
- Classe abstraite : non instanciable
- Classe finale : non dérivable
- Protection (publique/privée):
- Protégée
- Restreint à la sous-hierarchie (le type de l'objet représente la racine de la hierarchie d'accès à l'attribut)
- Publique
- La racine de la hiérarchie est telle que toutes les classes peuvent accéder à l'attribut
- Problèmes :
- Exposition de l'implémentation
- Héritage de l'interface de liste
- Héritage multiple : plusieurs classes mère
- Ambiguïtés
- Problème de performance
- Sous-classage :
- Héritage d'implémentation (réutilisabilité du code)
- Héritage d'interface (sémantique, sous-typage)
**Héritage d'implémentation => Héritage d'interface**
- Sous-typage :
Sous-entend que tout objet d'une classe peut être manipulé comme un objet d'une super-classe
- Héritage par restriction
- Imposer des contraintes plus fortes dans la sous-classe que dans la super-classe
- Programmation différentielle
- Hériter de manière additive au lieu de restrictive
- Problème de mutation
- Ambiguïtés
- Héritage en diamant = duplication ou non de la classe commune

### Historique

* Smalltalk (1971 + 1980)
- Alan Kay + Dan Ingalls
- 1er langage POO
- DynaBook 1972
* Simula (1962 + 1967)
- Ole-Johan Dalh + Kristen Nygaard
- Smalltalk
- Origine du modèle de Hoare
- Origine des mécanismes orienté objet

Actuellement :

- Standardisation
* OMG (Object Management Group) : 1989
* UML (Unified Modelling Language) : Modelisation graphique

## Surcharge, Masquage, Ré-écriture

| Surcharge | Masquage | Ré-écriture |
| -------- | -------- | -------- |
| Même nom, signature différente | Même nom, signature différente ou identique | Même nom, même signature |
| Méthodes statiques/dynamiques + fonctions + opérateurs | Méthodes statiques/dynamique | Méthodes "virtuelles" |
| Dispatch statique | Dispatch statique | Dispatch dynamique |
| Polymorphisme intra-classe | Polymorphisme inter-classe | Polymorphisme intra-hierarchique (inclusion) |
|  |  |  |

Dispatch <=> Polymorphisme

Utilité
- Faire des choses un peu différemment
- Faire la même chose différemment
- Relation gène <-> allèle

Dispatch
* Statique => Optimisé, performant à la compilation
* Dynamique => Energivore, moins performant

Ré-écriture
* Satisfait la covariance sur son type de retour et la contravariance sur ses arguments

| Langage | Propagation de la surcharge | Masquage ≠ Ré-écriture |
| -------- | -------- | -------- |
| **Java** | Oui | Méthodes statiques si même signature |
| **C++** | Non, par défaut | Méthodes statiques uniquement |

## Méthodes abstraites

Méthode abstraites => Classe abstraites
- Classe abstraite = Classe non-instanciable
- Déclarée sans implémentation initiale
- Implémentée dans les sous-classes
- Méthode abstraite = méthode "virtuelle pure"

## Covariance et Contravariance

- Covariance
- un type lié à une hiérarchie de classe est spécialisé dans le même sens que l'héritage
- Contravariance