Introduction à la Programmation Orientée Objet

Ce matériel couvre une introduction à la Programmation Orientée Objet (POO) destinée aux étudiants de deuxième année de Licence en Business Computing. Il présente les concepts fondamentaux de la POO, les différences avec la programmation procédurale, ainsi que des exemples d'application en Java et en C pour illustrer ces notions.

Programmation procédurale

La programmation procédurale consiste à définir des variables (ensemble de données) et à diviser l’application en petits blocs de code appelés procédures ou fonctions. L’exécution d’un programme se réduit à appeler ces procédures/fonctions dans un ordre précis, en leur fournissant les données nécessaires à l’accomplissement de leurs tâches.

Par exemple, en langage C, un programme procédural peut gérer une pile avec des fonctions telles que :

bool Pile_vide()
bool Pile_pleine()
void Initialiser_pile() { haut = 0; }
void Inserer_pile(float valeur) {
  vecteur[haut] = valeur;
  haut += 1;
}
float Acces_pile() {
  return vecteur[haut - 1];
}
void Enlever_pile() {
  haut = haut - 1;
  vecteur[haut] = 0;
}

Le programme principal utilise ces fonctions pour manipuler la pile :

void main() {
  Initialiser_pile();
  Inserer_pile(2.3f);
  Inserer_pile(3.4f);
  Inserer_pile(6.3f);
  while (!Pile_vide()) {
    Enlever_pile();
  }
}

Limites de la programmation procédurale

• Absence de cadre bien défini pour organiser les fonctions.
• Modification d’une fonction pouvant entraîner la modification d’une autre.
• Difficulté à gérer la portée des modifications.
• Redondance du code.
• Propagation des erreurs et débogage difficile.

De la programmation procédurale à la Programmation Orientée Objet (POO)

La programmation procédurale distingue les programmes (éléments actifs) des données (éléments passifs). En revanche, la POO est fondée sur une seule catégorie d’éléments : les objets, qui communiquent entre eux par l’envoi de messages (méthodes).

Un objet est l’équivalent d’une variable (simple ou structurée) dans un langage impératif typé, et la classe dont il est l’instance correspond au type de cette variable.

La POO offre plusieurs avantages :

• Développement plus facile et souvent plus rapide.
• Fonctionnement plus stable.
• Maintenance simplifiée.
• Augmentation de la qualité des logiciels (moins de bugs).
• Approche plus proche de la manière dont nous concevons le monde réel.
• Base des langages modernes comme C++, C#, Java, Python, PHP, etc.

Définition d’un objet et d’une classe

Un objet est un élément tiré du monde réel, caractérisé par :

• Des frontières précises.
• Une identité (ou référence).
• Un ensemble d’attributs (propriétés) décrivant son état.
• Un ensemble de méthodes (opérations) définissant son comportement.

Une classe est la description d’un ensemble d’objets communs, caractérisés par des attributs et des méthodes partagés. Un objet est une instance d’une classe.

Exemple d’application : gestion du personnel d’une entreprise

On souhaite réaliser un programme de gestion du personnel d’une entreprise informatique comprenant différents types d’employés : ingénieurs, techniciens, directeurs, ouvriers d’entretien (concierge, femme de ménage, etc.).

La programmation procédurale diviserait ce programme en fonctions manipulant des données globales, tandis que la POO modéliserait chaque catégorie d’employés par une classe avec ses attributs et méthodes.

Comparaison entre programmation procédurale et orientée objet

Aspect	Programmation procédurale	Programmation orientée objet
Organisation du programme	Le programme principal est divisé en petites fonctions.	Le programme est divisé en objets représentant les données et les fonctions.
Gestion des données	Les données sont souvent globales, sans spécificateurs d’accès.	Chaque objet contrôle ses propres données avec des spécificateurs d’accès (public, private, protected).
Communication	Les fonctions communiquent entre elles selon les règles habituelles.	Les objets communiquent par envoi de messages (appel de méthodes).
Importance	Les fonctions et algorithmes sont prioritaires par rapport aux données.	Les données (objets) ont plus d’importance que les fonctions.

Exemple d’application : gestion des étudiants

On veut écrire un programme qui détermine si un étudiant a réussi son année. Les étudiants de première et deuxième année sont décrits par :

• num, nom, adresse, moyenneS1, moyenneS2
• La moyenne est calculée par : (moyenneS1 + moyenneS2) / 2

Les étudiants de troisième année sont décrits par :

• num, nom, adresse, moyenneS1, notePFE
• La moyenne est calculée par : (moyenneS1 * 2 + notePFE) / 3

Le programme demande à saisir les informations de 30 étudiants et affiche s’ils ont réussi ou non.

Définition des données en programmation procédurale (C)

struct etudiant {
  int num;
  char nom[30];
  char adresse[30];
  int classe;
  float noteS1;
  float noteS2;
  float notePFE;
};

On peut stocker les données de tous les étudiants dans un tableau de 10 étudiants, chaque indice correspondant au rang de l’étudiant.

Découpage du programme procédural

Pour simplifier, on définit une fonction qui calcule la moyenne d’un étudiant de première ou deuxième année, et une autre pour les étudiants de troisième année.

Extrait du programme principal en C

#include <stdio.h>
#include <conio.h>

struct etudiant {
  int num;
  char nom[30];
  char adresse[30];
  int classe;
  float noteS1;
  float noteS2;
  float notePFE;
};

void rem(struct etudiant *p) {
  int i;
  for(i = 0; i < 10; i++) {
    printf("étudiant no : %d\n", i+1);
    printf("entrez le nom de cet étudiant : ");
    scanf("%s", &(*(p+i)).nom);
    printf("entrez l'adresse de cet étudiant : ");
    scanf("%s", &(*(p+i)).adresse);
    printf("entrez la classe de cet étudiant : ");
    scanf("%d", &(*(p+i)).classe);
    if((*(p+i)).classe == 1 || (*(p+i)).classe == 2) {
      printf("entrez la moyenne de S1 de cet étudiant : ");
      scanf("%f", &(*(p+i)).noteS1);
      printf("entrez la moyenne de S2 de cet étudiant : ");
      scanf("%f", &(*(p+i)).noteS2);
    }
    // Suite à compléter pour la 3ème année...
  }
}

Programmation orientée objet appliquée aux étudiants

En POO, on définit plusieurs classes pour représenter les étudiants selon leur année :

• Classe Etudiant :
  Attributs : num, nom, adresse, noteS1
  Méthodes : ajouter(), calculerMoyenne(), afficher()
• Classe EtudiantL1L2 :
  Attributs : num, nom, adresse, noteS1, noteS2
  Méthodes : ajouter(), calculerMoyenne(), afficher()
• Classe EtudiantL3 :
  Attributs : num, nom, adresse, noteS1, notePFE
  Méthodes : ajouter(), calculerMoyenne(), afficher()

Glossaire des termes clés

• Objet : Élément issu du monde réel, possédant une identité, des attributs (état) et des méthodes (comportement).
• Classe : Description d’un ensemble d’objets partageant des attributs et des méthodes communes.
• Attribut : Propriété ou donnée décrivant l’état d’un objet.
• Méthode : Fonction ou opération définissant le comportement d’un objet.
• Encapsulation : Principe qui consiste à regrouper données et méthodes dans une même unité (classe) et à contrôler l’accès aux données.
• Héritage : Mécanisme permettant à une classe de dériver d’une autre, héritant ainsi de ses attributs et méthodes.
• Polymorphisme : Capacité d’un objet à prendre plusieurs formes, notamment par redéfinition de méthodes.
• Classe abstraite : Classe qui ne peut pas être instanciée directement et sert de modèle pour d’autres classes.
• Interface : Ensemble de méthodes sans implémentation que les classes peuvent implémenter.

Points clés à retenir

• La programmation procédurale sépare données et fonctions, ce qui peut rendre les programmes complexes difficiles à maintenir.
• La POO regroupe données et comportements dans des objets, facilitant la modélisation du monde réel.
• Une classe définit les caractéristiques communes d’un ensemble d’objets.
• Les objets communiquent entre eux par l’envoi de messages (appel de méthodes).
• La POO améliore la maintenance, la réutilisation et la qualité du code.
• Les concepts fondamentaux de la POO sont : encapsulation, héritage, polymorphisme, classes abstraites et interfaces.
• La maîtrise de la POO permet de développer des applications robustes en Java et autres langages orientés objet.