Fiche de révision : Introduction à la Programmation Orientée Objet

📋 Plan du Cours

1. Concept d’objet en programmation orientée objet
2. Pourquoi utiliser la programmation orientée objet
3. Classe, objet et instanciation en POO
4. Attributs et structure d’une classe Python
5. Création d’objets et accès aux attributs
6. Méthodes et différence fonction méthode
7. Constructeur init et encapsulation
8. Méthodes magiques et compatibilité Python
9. Accesseurs et mutateurs pour protéger les données

📖 1. Concept d’objet en programmation orientée objet

🔑 Notions clés & Définitions

• Objet : Un objet est une donnée construite à partir d’un modèle, qui regroupe des informations et des actions associées.
• Attribut : Un attribut est une caractéristique stockée dans un objet, comme une valeur décrivant son état.
• Méthode : Une méthode est une action définie dans une classe pour manipuler les attributs d’un objet.
• Paradigme orienté objet : Un paradigme orienté objet organise le code autour d’objets représentant des entités du monde réel.

📝 Points essentiels

• En Python, les chaînes et les listes sont déjà des objets manipulés via des méthodes.
• Les objets sont manipulés indirectement : on agit sur eux par des méthodes plutôt que par des opérations brutes.
• Un objet combine toujours des données (attributs) et des comportements (méthodes).
• La POO vise à organiser le code autour de concepts du réel, pas seulement autour de fonctions et variables isolées.
• Les attributs décrivent l’état (ex. nom, âge), tandis que les méthodes décrivent ce que l’objet peut faire (ex. parler, démarrer).

💡 Astuce mémo

Objet = Données + Actions (Attributs + Méthodes).

📖 2. Pourquoi utiliser la programmation orientée objet

🔑 Notions clés & Définitions

• Modularité : La modularité est la découpe du code en unités réutilisables, ici des objets.
• Maintenabilité : La maintenabilité désigne la facilité à comprendre et modifier un code structuré en objets.
• Réutilisabilité : La réutilisabilité est la capacité d’utiliser des objets dans plusieurs projets.
• Modélisation : La modélisation est la représentation de concepts complexes à l’aide d’objets et de leurs interactions.

📝 Points essentiels

• La modularité vient du fait que les objets servent de briques réutilisables.
• La maintenabilité augmente car le code est plus clair et plus simple à faire évoluer.
• La réutilisabilité permet de reprendre des objets dans d’autres projets sans tout refaire.
• La modélisation rend plus simple la représentation de situations complexes via des objets.
• La POO aide à structurer le programme autour de comportements et d’états cohérents plutôt que d’algorithmes dispersés.

💡 Astuce mémo

4M : Modularité, Maintenabilité, Réutilisabilité, Modélisation.

📖 3. Classe, objet et instanciation en POO

🔑 Notions clés & Définitions

• Classe : Une classe est un plan qui décrit les attributs et les méthodes d’un objet.
• Objet : Un objet est une instance concrète créée à partir d’une classe.
• Instanciation : L’instanciation est le processus de création d’un objet à partir d’une classe.
• Héritage : L’héritage est un mécanisme qui permet de créer de nouvelles classes en reprenant des attributs et méthodes d’une classe existante.

📝 Points essentiels

• Une classe sert de moule : elle définit la structure, mais n’est pas l’objet lui-même.
• Un objet correspond à un exemplaire : il porte des valeurs réelles pour ses attributs.
• L’instanciation produit une instance à partir du plan de la classe.
• L’héritage permet de construire une classe nouvelle en réutilisant ce qui existe déjà.
• Dans l’exemple, Eleve est la classe et e1 est l’objet (instance) créé.

💡 Astuce mémo

Classe = moule ; Objet = gâteau ; Instanciation = fabrication du gâteau.

📖 4. Attributs et structure d’une classe Python

🔑 Notions clés & Définitions

• Mot-clé class : Le mot-clé class introduit la définition d’une classe en Python.
• init : init est une fonction spéciale appelée pour initialiser les attributs lors de la création d’un objet.
• self : self désigne l’objet courant à l’intérieur des méthodes, pour accéder à ses attributs.
• Attribut d’instance : Un attribut d’instance est une donnée stockée dans chaque objet, accessible via self.
• Attribut de classe : Un attribut de classe est une valeur attachée à la classe elle-même, partagée et consultable depuis la classe ou une instance.

📝 Points essentiels

• En Python, le nom de la classe commence par une lettre majuscule dans l’exemple (Eleve).
• La structure typique inclut une définition de classe puis des méthodes, dont init.
• Dans init, self.nom, self.age et self.niveau stockent les valeurs propres à l’objet.
• Les attributs d’instance sont mutables : on peut les consulter et les modifier.
• Un attribut de classe (ex. classe_max) se lit depuis une instance et depuis la classe.
• Les attributs de classe sont attachés à la classe, pas à un objet unique.

💡 Astuce mémo

self = l’objet courant ; init = remplissage des attributs au moment de la création.

📖 5. Création d’objets et accès aux attributs

🔑 Notions clés & Définitions

• Instance : Une instance est un objet créé à partir d’une classe, avec ses valeurs d’attributs.
• Création d’objet : La création d’objet consiste à appeler la classe comme une fonction pour déclencher l’instanciation.
• Accès attribut : L’accès à un attribut consiste à lire la valeur stockée dans l’objet via la notation pointée.
• Modification attribut : La modification d’attribut est l’opération qui change la valeur d’un attribut d’un objet.

📝 Points essentiels

• On crée un objet en appelant la classe : e1 = Eleve("Alice", 17, "Terminale").
• e1 représente un objet de la classe Eleve avec des attributs initialisés.
• Pour lire un attribut, on utilise la notation pointée : e1.nom, e1.age, e1.niveau.
• Les attributs d’instance sont mutables : on peut faire e1.age = 18.
• L’accès aux attributs de classe est possible depuis l’instance et depuis la classe (e1.classe_max et Eleve.classe_max).
• Après modification, les nouvelles valeurs sont visibles immédiatement via les mêmes accès.

💡 Astuce mémo

Notation pointée : objet.attribut (lecture ou écriture).

📖 6. Méthodes et différence fonction méthode

🔑 Notions clés & Définitions

• Fonction : Une fonction est définie en dehors d’une classe et agit sur des valeurs fournies en paramètres.
• Méthode : Une méthode est une fonction définie dans une classe et destinée à agir sur les attributs d’un objet.
• Paramètre self : Le paramètre self est le premier argument d’une méthode et représente l’objet sur lequel la méthode s’exécute.
• Méthode d’instance : Une méthode d’instance est appelée sur un objet et manipule ses attributs via self.

📝 Points essentiels

• Une méthode est définie à l’intérieur d’une classe, contrairement à une fonction définie à l’extérieur.
• Le premier paramètre d’une méthode est toujours self dans l’exemple.
• self permet de lire et modifier les attributs de l’objet courant.
• La méthode presentation utilise self.nom, self.age et self.niveau pour construire une chaîne.
• La méthode anniversaire modifie l’état en augmentant self.age de 1.
• Appeler une méthode se fait avec la notation pointée : e1.presentation() ou e1.anniversaire().

💡 Astuce mémo

Fonction = valeurs ; Méthode = objet (self) + ses attributs.

📖 7. Constructeur init et encapsulation

🔑 Notions clés & Définitions

• Constructeur init : Le constructeur init initialise les attributs d’un objet dès sa création.
• Encapsulation : L’encapsulation consiste à protéger les données internes d’un objet en évitant leur modification directe depuis l’extérieur.
• Attribut privé : Un attribut privé est indiqué par un préfixe __ et est destiné à ne pas être manipulé directement.
• Convention de confidentialité : La convention de confidentialité indique que le préfixe __ signale un attribut privé, même si l’accès reste techniquement possible.

📝 Points essentiels

• init est appelée lors de la création de l’objet, avant l’utilisation des attributs.
• Dans l’exemple encapsulé, les attributs sont stockés sous __nom, __age et __niveau.
• Le but de l’encapsulation est d’empêcher l’extérieur de modifier directement les données internes.
• On préfère passer par des méthodes prévues pour lire ou changer l’état.
• Le préfixe __ sert de convention pour indiquer la confidentialité des attributs.
• L’encapsulation n’est pas une barrière absolue : l’attribut reste techniquement accessible malgré la convention.

💡 Astuce mémo

init = création ; __... = données protégées (encapsulation par convention).

📖 8. Méthodes magiques et compatibilité Python

🔑 Notions clés & Définitions

• Méthode magique : Une méthode magique est une méthode Python dont le nom est entouré de __ et appelée automatiquement par le langage.
• str : str définit la représentation en chaîne d’un objet, utilisée par print et str(objet).
• lt : lt définit le comportement de comparaison avec l’opérateur < entre deux objets.
• Compatibilité avec opérations Python : La compatibilité avec les opérations Python signifie que les objets réagissent aux opérations habituelles grâce à des méthodes spéciales.

📝 Points essentiels

• init est appelée à la création d’un objet, tandis que str et lt sont déclenchées par des opérations du langage.
• str est utilisée quand on applique str(objet) ou print(objet).
• Dans l’exemple, str renvoie une chaîne contenant nom, âge et niveau.
• lt est appelée quand on utilise l’opérateur < entre deux instances.
• Dans l’exemple, lt compare les âges : self.__age < autre.__age.
• Chaque classe définit son propre comportement pour ces opérations, sans confusion entre objets.

💡 Astuce mémo

str = afficher ; lt = comparer (<).

📖 9. Accesseurs et mutateurs pour protéger les données

🔑 Notions clés & Définitions

• Accesseur : Un accesseur est une méthode qui renvoie la valeur d’un attribut interne.
• Mutateur : Un mutateur est une méthode qui modifie la valeur d’un attribut interne.
• Getter : Un getter est un accesseur qui permet de lire une donnée protégée.
• Setter : Un setter est un mutateur qui permet de changer une donnée protégée avec des contrôles.

📝 Points essentiels

• Pour protéger __age, on utilise un accesseur get_age qui renvoie la valeur interne.
• Pour modifier __age, on utilise un mutateur set_age qui applique une règle avant d’écrire.
• Dans l’exemple, set_age refuse les âges négatifs en ne mettant pas à jour la valeur si nouvel_age < 0.
• Après un set_age valide, get_age renvoie la nouvelle valeur.
• Après un set_age invalide (négatif), la valeur reste inchangée.
• L’accès via getters/setters rend la modification plus sûre et permet d’imposer des contraintes.

💡 Astuce mémo

Getter = lire ; Setter = écrire avec contrôle (ex. pas d’âge négatif).

📊 Tableaux de synthèse

Fonction vs méthode

⚠️ Pièges & confusions fréquents

1. Confondre classe et objet : la classe est un plan, l’objet est l’instance créée.
2. Oublier que les méthodes utilisent self : sans self, on ne peut pas accéder aux attributs de l’objet.
3. Croire que l’encapsulation avec __ empêche totalement l’accès : c’est surtout une convention de confidentialité.
4. Confondre str et init : init initialise à la création, str sert à l’affichage.
5. Penser que set_age modifie toujours l’attribut : dans l’exemple, les âges négatifs sont refusés.
6. Mélanger attribut d’instance et attribut de classe : l’un dépend de chaque objet, l’autre est attaché à la classe.

✅ Checklist Examen

1. Définir objet, attribut et méthode, et expliquer le rôle de la POO par rapport aux variables/fonctions procédurales.
2. Citer les raisons d’utiliser la POO : modularité, maintenabilité, réutilisabilité, modélisation.
3. Distinguer classe, objet et instanciation, et reconnaître le rôle de l’héritage dans la POO.
4. Reconnaître la structure d’une classe Python : mot-clé class, méthode init, usage de self.
5. Savoir créer un objet à partir d’une classe et accéder/modifier ses attributs via la notation pointée.
6. Expliquer la différence fonction vs méthode, et identifier le rôle du paramètre self.
7. Décrire le rôle du constructeur init et l’idée d’encapsulation avec attributs préfixés par __.
8. Associer les méthodes magiques à leurs déclencheurs : str pour print/str, lt pour <.
9. Savoir utiliser accesseurs et mutateurs (get_age/set_age) et appliquer la règle de refus des âges négatifs.