Introduction à la programmation orientée objet

Programmation – Session 4

  • Qu’est-ce qu’un paradigme de programmation ?
  • Concepts de base de la programmation orientée objet

Qu’est-ce qu’un paradigme de programmation ?

Définitions

Paradigme de programmation

Une méthode ou un style de programmation qui définit un ensemble de principes, techniques et modèles pour structurer le code afin de résoudre des problèmes sur un ordinateur.

Paradigme procédural

  • De nombreux paradigmes existent (procédural, fonctionnel, logique…)
  • Jusqu’à présent dans le cours : programmation procédurale et modularité
    • Création de fonctions dans des modules et réutilisation avec des instructions import
    • Mais rien n’a été dit à propos des données. Où les définir ?

Qu’est-ce qu’un paradigme de programmation ?

Programmation orientée objet

Définition

Un paradigme de programmation basé sur le concept d’objets, qui peuvent contenir des données et du code : des données sous forme de champs (souvent appelés attributs ou propriétés), et du code sous forme de procédures (souvent appelées méthodes).

Remarques

  • Les attributs et les méthodes qui les manipulent sont regroupés dans la même entité (objets)
  • En POO, un programme informatique est conçu comme des objets qui interagissent entre eux pour implémenter des fonctionnalités.

Concepts de base de la programmation orientée objet

Objets, attributs et méthodes

Concepts de base de la programmation orientée objet

Classes, instanciation, constructeurs

  • Une classe définit la structure (attributs) et le comportement (méthodes) d’une famille d’objets. Elle se compose de :

    • un nom,
    • des attributs (leur nom et, si applicable, leur type),
    • des méthodes (leur nom, type de retour, nom et, si applicable, type de chaque argument, et leur code),
    • un constructeur, une méthode particulière appelée lors de la création d’un objet et dont le rôle est d’initialiser les attributs de l’objet

  • Un objet est créé à partir d’une classe

Concepts de base de la programmation orientée objet

Classes, instanciation, constructeurs

Class creation

class Person:
    """ Represents a person with a name, firstname, age, and city."""

    def __init__(self, name: str, firstname: str, age: int, city: str) -> None: # The constructor
        """ Constructs a new Person object with the specified name, firstname, age, and city."""
        self.name: str = name
        self.firstname: str = firstname
        self.age: int = age
        self.city: str = city

    def to_string(self) -> str:
        """ Returns a string representation of the person. """
        return f"{self.firstname} {self.name} ({self.age} old, from {self.city})"

Class instantiation (object creation)

if __name__ == '__main__':
  # Create a person named Alice Weber from London and 33 years old
  one_person = Person("Weber", "Alice", 33, "London")
  print(one_person.to_string())

  # Create a person named Bob Smith from Brighton and 25 years old
  a_second_person = Person("Smith", "Bob", 25, "Brighton")
  print(a_second_person.to_string())

Concepts de base de la programmation orientée objet

Encapsulation

Définition

Le principe de cacher ou protéger (une partie de) l’état d’un objet afin qu’il ne puisse pas être accédé depuis l’extérieur de la classe.

  • L’attribut city est par convention privé aux objets Person
class Person:
    """
    Represents a person with a name, firstname, age, and city.
    """
    def __init__(self, name: str, firstname: str, age: int, city: str) -> None: # The constructor
        """
        Constructs a new Person object with the specified name, firstname, and city.
        """
        self.name: str = name
        self.firstname: str = firstname
        self.age: int = age
        self._city: str = city

    def to_string(self) -> str:
        """ Returns a string representation of the person."""

        return f"{self.firstname} {self.name} ({self.age} old, from {self._city})"

if __name__ == '__main__':
    one_person = Person("Weber", "Alice", 33, "London")
    print(one_person.name) # No error. Expected output: "Weber"
    print(one_person._city) # No error. Expected output: "London"

Concepts de base de la programmation orientée objet

Héritage

Définition

Une façon de structurer le code qui définit des relations hiérarchiques entre les classes.

from person import Person

class Student(Person):
    """Represents a student of IMT Atlantique."""

    # It is good practice to also call the parent's constructor
    # Then you can complement with additional codes if needed
    def __init__(self, studentid: int, name: str, firstname: str, age: int, city: str) -> None:  # The constructor
        """Constructs a new student object with the specified studentid, name, firstname, age, and city."""

        super().__init__(name, firstname, age, city)  # Call parent's constructor
        self._studentid: int = studentid
        self._courses: list[str] = []

    def to_string(self) -> str:
        """Returns a string representation of the person."""

        return (
            f"{self._studentid}, " + super().to_string() + ". Enrolled in " + str(self._courses)
        )

    def enroll_in_course(self, course_name):
        """Add the course_name in the list of courses of the student."""

        if course_name not in self._courses:
            self._courses.append(course_name)


if __name__ == "__main__":
    one_student = Student(1234, "Weber", "Alice", 33, "London")
    print(
        one_student.to_string()
    )  # Expected output: "1234, Alice Weber (33 old, from London). Enrolled in []"

    one_student.enroll_in_course("UE Informatique")
    print(
        one_student.to_string()
    )  # Expected output: "1234, Alice Weber (33 old, from London). Enrolled in [UE Informatique]"

Récapitulatif de la session

Et ensuite ?

Activité pratique (~2h30)

Implémentez vos premiers programmes orientés objet

  • Créer et instancier des classes
  • Écrire et exécuter des programmes orientés objet

Après la session

  • Relire les articles de la session
  • Vérifier votre compréhension avec le quiz
  • Compléter l’activité pratique non optionnelle
  • Consulter la section “Avant le cours” de la session suivante