CHAPITRE 1 : Concepts de la POO

(CM : 5 TD : 6 TP : 3) 14h
Introduction

La programmation orientée objet (POO) est un paradigme de programmation qui

permet de modéliser le monde réel en utilisant des objets. Un objet est une entité qui
possède une structure interne et un comportement. La structure interne d'un objet est
définie par ses attributs, qui sont des données qui décrivent l'objet. Le comportement
d'un objet est défini par ses méthodes, qui sont des fonctions qui peuvent être
exécutées sur l'objet.

Les concepts de base de la POO sont les suivants :

• Encapsulation : la structure interne d'un objet est cachée des autres objets.
Cela permet de protéger les données et le comportement de l'objet.
• Héritage : une classe peut hériter des attributs et des méthodes d'une autre
classe. Cela permet de réutiliser le code et de créer des classes plus
complexes à partir de classes plus simples.
• Polymorphisme : une référence d'objet peut faire référence à un objet de
n'importe quelle classe qui hérite de la classe de l'objet. Cela permet d'utiliser
le même code pour traiter des objets de types différents.
Les avantages de la POO

La POO offre un certain nombre d'avantages, notamment :

• La modularité : la POO permet de diviser le code en modules indépendants,

ce qui facilite la compréhension et la maintenance du code.
• La réutilisation : la POO permet de réutiliser le code, ce qui permet de réduire
le temps de développement et les coûts de maintenance.
• La cohérence : la POO permet de garantir que les objets implémentent un
ensemble de méthodes de manière cohérente.
• La lisibilité : la POO permet de modéliser le monde réel de manière intuitive,
ce qui facilite la compréhension du code.
Les applications de la POO

La POO est un paradigme de programmation très répandu. Elle est utilisée dans un
large éventail d'applications, notamment :
 • Les applications logicielles : la POO est utilisée pour développer des
applications logicielles de toutes tailles, des petits programmes aux grands
systèmes d'information.
• Les systèmes d'exploitation : les systèmes d'exploitation modernes sont basés
sur la POO.
• Les bases de données : les bases de données relationnelles sont souvent
modélisées à l'aide de la POO.
• Les systèmes embarqués : la POO est utilisée pour développer des systèmes
embarqués, tels que les systèmes de contrôle industriels et les appareils
électroniques grand public.
Conclusion

La POO est un paradigme de programmation puissant et polyvalent qui peut être

utilisé pour développer des applications de haute qualité.

I. Encapsulation
L'encapsulation est un principe fondamental de la programmation orientée objet
(POO). Il consiste à regrouper les données et les comportements associés au sein
d'une même entité, appelée classe ou objet. L'encapsulation permet de masquer les
détails d'implémentation d'une classe ou d'un objet, et de n'exposer que les
fonctionnalités nécessaires à son utilisation.

1. Les principaux avantages de l'encapsulation sont les suivants :

• Amélioration de la modularité : l'encapsulation permet de décomposer un

programme en modules indépendants les uns des autres. Cela facilite le
développement et la maintenance du programme.
• Amélioration de la sécurité : l'encapsulation permet de protéger les données et
les comportements d'une classe ou d'un objet contre les accès non autorisés.
• Amélioration de la réutilisabilité : l'encapsulation permet de réutiliser les
classes et les objets sans avoir à connaître leur implémentation interne.

2. Les modificateurs d’accès

Pour mettre en œuvre l'encapsulation, on utilise généralement des modificateurs
d'accès pour contrôler la visibilité des attributs et des méthodes d'une classe. Les
modificateurs d'accès les plus courants sont :

• public : l'attribut ou la méthode est accessible depuis n'importe quelle classe.

• private : l'attribut ou la méthode est accessible uniquement depuis la classe
dans laquelle il est défini.
• protected : l'attribut ou la méthode est accessible depuis la classe dans
laquelle il est défini, ainsi que depuis les classes dérivées de cette classe.

Voici un exemple de classe en Java qui utilise l'encapsulation :

Java
public class Personne {

private String nom;

private int age;

public Personne(String nom, int age) {

this.nom = nom;
this.age = age;
}

public String getNom() {

return nom;
}

public int getAge() {

return age;
}

public void setNom(String nom) {

this.nom = nom;
}

public void setAge(int age) {

this.age = age;
}
}
Dans cette classe, les attributs nom et age sont privés. Cela signifie qu'ils ne sont
accessibles que depuis la classe Personne. Les méthodes getNom(), getAge(),
setNom() et setAge() permettent d'accéder aux attributs nom et age de manière
contrôlée.
Pour utiliser la classe Personne, on peut créer une instance de cette classe et
appeler les méthodes getNom() et getAge() pour obtenir les informations sur la
personne, et les méthodes setNom() et setAge() pour modifier ces informations.
Voici un exemple d'utilisation de la classe Personne :
Java
Personne personne = new Personne("John Doe", 30);

String nom = personne.getNom();

int age = personne.getAge();

System.out.println("Nom : " + nom);

System.out.println("Age : " + age);

personne.setNom("Jane Doe");
personne.setAge(31);

System.out.println("Nom : " + personne.getNom());

System.out.println("Age : " + personne.getAge());

Cet exemple produira le résultat suivant :

Nom : John Doe

Age : 30
Nom : Jane Doe
Age : 31

Comme vous pouvez le voir, l'encapsulation permet d'accéder aux données et aux
comportements d'une classe de manière contrôlée. Cela permet d'améliorer la
sécurité, la modularité et la réutilisabilité du programme.

II. Héritage
En programmation orientée objet (POO), l'héritage est un mécanisme qui permet à
une classe de réutiliser les propriétés et les méthodes d'une autre classe. La classe
qui hérite est appelée classe enfant ou classe dérivée, et la classe dont elle hérite est
appelée classe parent ou classe de base.

L'héritage est un concept important en POO car il permet de réduire la duplication de

code et de simplifier la maintenance du code. Il permet également de créer des
hiérarchies de classes, ce qui peut être utile pour modéliser des relations entre des
objets du monde réel.
En algorithmique, l'héritage peut être utilisé pour représenter des relations entre des
objets. Par exemple, on peut utiliser l'héritage pour représenter la relation entre un
animal et un chien. La classe Animal serait la classe parent, et la classe Chien serait
la classe enfant. La classe Chien hériterait des propriétés et des méthodes de la
classe Animal.

Voici un exemple d'utilisation de l'héritage en algorithmique :

Python
class Animal:
def __init__(self, nom):
self.nom = nom

def faire_du_bruit(self):
print("Je fais du bruit !")

class Chien(Animal):
def __init__(self, nom, race):
super().__init__(nom)
self.race = race

def aboyer(self):
print("Wouf !")

chien = Chien("Rex", "Golden Retriever")

chien.faire_du_bruit() # "Je fais du bruit !"
chien.aboyer() # "Wouf !"
Dans cet exemple, la classe Chien hérite de la classe Animal. Cela signifie que la
classe Chien possède les mêmes propriétés et méthodes que la classe Animal.
Dans cet exemple, la classe Animal possède une propriété nom et une méthode
faire_du_bruit(). La classe Chien hérite de ces propriétés et méthodes, ce qui
signifie qu'un objet Chien possède une propriété nom et peut appeler la méthode
faire_du_bruit().
En plus de la propriété nom et de la méthode faire_du_bruit(), la classe Chien
possède une propriété race et une méthode aboyer(). La méthode aboyer() est
spécifique à la classe Chien.

L'héritage est un concept puissant qui peut être utilisé pour simplifier et améliorer la
qualité du code.
 III. Polymorphisme
En programmation orientée objet (POO), le polymorphisme est un concept qui permet
d'utiliser une même interface pour des objets de types différents. Cela signifie que les
objets peuvent avoir des comportements différents, mais ils peuvent être utilisés de la
même manière.

Il existe deux types de polymorphisme en POO :

• La surcharge des méthodes : permet à une classe d'avoir plusieurs méthodes

avec le même nom, mais avec des signatures différentes.
• L'héritage : permet à une classe de dériver d'une autre classe. Les classes
dérivées héritent de toutes les propriétés et méthodes de la classe parente.

En algorithmique, le polymorphisme peut être utilisé pour :

• Rendre le code plus générique : le polymorphisme permet de créer des

fonctions ou des algorithmes qui peuvent être utilisés avec des objets de
différents types.
• Réduire la duplication de code : le polymorphisme permet de réutiliser le code
pour des objets de différents types.
• Améliorer la lisibilité du code : le polymorphisme permet de simplifier le code
en cachant les détails de l'implémentation des objets.

Voici un exemple de polymorphisme en algorithmique :

C#
// Une classe abstraite qui représente une forme
abstract class Forme
{
public abstract double Perimetre();
}

// Une classe dérivée de Forme qui représente un cercle

class Cercle : Forme
{
private double rayon;

public Cercle(double rayon)

{
this.rayon = rayon;
}
 public override double Perimetre()
{
return 2 * Math.PI * rayon;
}
}

// Une classe dérivée de Forme qui représente un rectangle

class Rectangle : Forme
{
private double longueur;
private double largeur;

public Rectangle(double longueur, double largeur)

{
this.longueur = longueur;
this.largeur = largeur;
}

public override double Perimetre()

{
return 2 * (longueur + largeur);
}
}

// Une fonction qui calcule le périmètre d'une forme

public double PerimetreForme(Forme forme)
{
return forme.Perimetre();
}

// Exemple d'utilisation de la fonction PerimetreForme()

Forme forme = new Cercle(10);
double perimetre = PerimetreForme(forme);
Console.WriteLine(perimetre); // 62.83185307179586

forme = new Rectangle(10, 20);

perimetre = PerimetreForme(forme);
Console.WriteLine(perimetre); // 60
Dans cet exemple, la classe Forme est une classe abstraite qui représente une
forme. Les classes Cercle et Rectangle sont des classes dérivées de Forme qui
représentent respectivement un cercle et un rectangle.
La fonction PerimetreForme() prend une forme en entrée et calcule son périmètre.
La fonction utilise le polymorphisme pour appeler la méthode Perimetre() de la
forme en entrée, quel que soit son type.
Dans l'exemple, la fonction PerimetreForme() est appelée avec un cercle et un
rectangle. Dans les deux cas, la fonction renvoie le périmètre correct.
Le polymorphisme est un concept puissant qui peut être utilisé pour améliorer la
qualité du code.

IV. Classe et objet

En programmation orientée objet (POO), une classe est un modèle ou un prototype
qui définit les propriétés et les comportements communs à un ensemble d'objets. Une
classe peut être considérée comme une description d'un objet réel, tel qu'une
personne, une voiture ou un animal.

Les objets sont des instances de classes. Ils sont créés à partir d'une classe et
possèdent les propriétés et les comportements définis par la classe.

Propriétés

Les propriétés sont des données qui définissent l'état d'un objet. Elles peuvent être
des variables, des constantes ou des expressions.

Comportements

Les comportements sont des méthodes qui définissent ce qu'un objet peut faire.
Elles sont des fonctions qui peuvent être appelées sur un objet pour effectuer une
action.

Exemple

Voici un exemple de classe en C# :

C#
public class Personne
{
public string Nom { get; set; }
public int Age { get; set; }

public void SePresenter()

{
Console.WriteLine($"Je m'appelle {Nom} et j'ai {Age} ans.");
}
}
Cette classe définit les propriétés Nom et Age pour représenter les informations d'une
personne. Elle définit également la méthode SePresenter() qui permet à une
personne de se présenter.
Instanciation d'un objet

Pour créer un objet, on utilise l'opérateur new. Par exemple, pour créer un objet de
type Personne, on peut utiliser le code suivant :

C#
Personne personne = new Personne();
Cet objet aura les propriétés Nom et Age initialisées par défaut.
Attribution de valeurs
On peut ensuite attribuer des valeurs aux propriétés d'un objet. Par exemple, on peut
attribuer la valeur "Jean Dupont" à la propriété Nom de l'objet personne en utilisant le
code suivant :
C#
personne.Nom = "Jean Dupont";
On peut également appeler les méthodes d'un objet. Par exemple, on peut appeler la
méthode SePresenter() de l'objet personne en utilisant le code suivant :
C#
personne.SePresenter();

Ce code produira la sortie suivante :

Je m'appelle Jean Dupont et j'ai 0 ans.

Conclusion

Les classes et les objets sont des concepts fondamentaux de la POO. Ils permettent
de modéliser le monde réel de manière plus intuitive et efficace.

V. Constructeur
En programmation orientée objet (POO), un constructeur est
une méthode spéciale qui est appelée lorsqu'un objet est créé. Le constructeur est
utilisé pour initialiser les attributs de l'objet.

En algorithmique, un constructeur est un type particulier de fonction qui est utilisé

pour créer un objet. Le constructeur est utilisé pour initialiser les données de l'objet.
Concept de la POO

En POO, un objet est une entité qui possède des données et des méthodes. Les
données d'un objet sont appelées ses attributs. Les méthodes d'un objet sont
utilisées pour manipuler ses données.

Le constructeur est utilisé pour initialiser les attributs d'un objet lorsque celui-ci est
créé. Le constructeur est appelé automatiquement par le système lorsque l'objet est
créé.

Concept en algorithmique

En algorithmique, un objet est un type abstrait de données (TAD). Un TAD est un

type de données qui est défini par ses opérations.

Le constructeur est utilisé pour créer un objet. Le constructeur est appelé

automatiquement par le système lorsque l'objet est créé.

Exemple en POO

Voici un exemple de constructeur en POO :

C#
public class Personne
{
public string Nom { get; set; }
public int Age { get; set; }

public Personne(string nom, int age)

{
Nom = nom;
Age = age;
}
}
Ce constructeur prend deux paramètres : le nom et l'âge de la personne. Le
constructeur utilise ces paramètres pour initialiser les attributs Nom et Age de l'objet.
Exemple en algorithmique

Voici un exemple de constructeur en algorithmique :

Python
class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age
Ce constructeur prend deux paramètres : le nom et l'âge de la personne. Le
constructeur utilise ces paramètres pour initialiser les attributs nom et age de l'objet.
Conclusion

Le constructeur est un concept important de la POO et de l'algorithmique. Le

constructeur est utilisé pour initialiser les données d'un objet lorsque celui-ci est créé.

VI. Surcharge et redéfinition

En programmation orientée objet (POO), la surcharge et la
redéfinition sont deux concepts qui permettent de réutiliser le code et de le rendre plus
flexible.

La surcharge permet de définir plusieurs méthodes de même nom dans une même
classe, mais avec des signatures différentes. La signature d'une méthode est définie
par son nom, ses paramètres et son type de retour.
La redéfinition permet de redéfinir une méthode dans une classe fille qui hérite d'une
classe mère. La méthode redéfinie doit avoir la même signature que la méthode
définie dans la classe mère.
Exemple de surcharge
C#
class Point
{
public int X { get; set; }
public int Y { get; set; }

public double Distance(Point point)

{
// Calcule la distance entre deux points
return Math.Sqrt(Math.Pow(X - point.X, 2) + Math.Pow(Y -
point.Y, 2));
}

public double Distance(int x, int y)

{
// Calcule la distance entre un point et un point spécifié
return Math.Sqrt(Math.Pow(X - x, 2) + Math.Pow(Y - y, 2));
}
}
Dans cet exemple, la classe Point définit deux méthodes Distance(). La première
méthode prend un point en paramètre et calcule la distance entre les deux points. La
deuxième méthode prend deux entiers en paramètre et calcule la distance entre un
point et un point spécifié.
Exemple de redéfinition
C#
class Animal
{
public void Manger()
{
// Méthode de base pour manger
Console.WriteLine("L'animal mange.");
}
}

class Chien : Animal

{
public override void Manger()
{
// Méthode redéfinie pour manger comme un chien
Console.WriteLine("Le chien mange de la viande.");
}
}

class Chat : Animal

{
public override void Manger()
{
// Méthode redéfinie pour manger comme un chat
Console.WriteLine("Le chat mange du poisson.");
}
}
Dans cet exemple, la classe Animal définit une méthode Manger() qui est
implémentée de manière générique. La classe Chien redéfinit la méthode Manger()
pour qu'elle imprime un message indiquant que le chien mange de la viande. La
classe Chat redéfinit également la méthode Manger() pour qu'elle imprime un
message indiquant que le chat mange du poisson.
En algorithmique

Les concepts de surcharge et de redéfinition peuvent être appliqués à l'algorithmique

pour réutiliser le code et le rendre plus flexible.

Par exemple, une fonction de calcul de la distance entre deux points peut être
surchargée pour prendre en compte différents types de points. Une fonction de tri
peut être redéfinie pour utiliser un algorithme de tri différent.
Conclusion

La surcharge et la redéfinition sont des concepts importants en POO qui permettent

de réutiliser le code et de le rendre plus flexible. Ces concepts peuvent également
être appliqués à l'algorithmique pour les mêmes raisons.

VII. Classe abstraite et interface

En programmation orientée objet (POO), une classe abstraite
est une classe qui ne peut pas être instanciée. Elle est utilisée pour définir un ensemble
de méthodes et d'attributs qui doivent être implémentés par les classes concrètes qui
en héritent.

Une interface est une classe qui ne contient que des méthodes abstraites. Elle est
utilisée pour définir un ensemble de méthodes que les classes concrètes doivent
implémenter.

En algorithmique, les classes abstraites et les interfaces peuvent être utilisées pour :

• Définir une structure commune : une classe abstraite peut être utilisée pour
définir une structure commune à plusieurs classes concrètes. Cela permet de
faciliter la réutilisation du code et de réduire la duplication de code.
• Assurer la cohérence : une interface peut être utilisée pour garantir que les
classes concrètes implémentent un ensemble de méthodes de manière
cohérente. Cela permet de faciliter la maintenance du code et d'améliorer la
fiabilité des applications.
Exemple de classe abstraite

Voici un exemple de classe abstraite en C# :

C#
public abstract class Figure
{
public abstract double Aire();
public abstract double Perimetre();
}
Cette classe abstraite définit deux méthodes abstraites : Aire() et Perimetre(). Ces
méthodes doivent être implémentées par les classes concrètes qui en héritent.
Exemple d'interface
Voici un exemple d'interface en C# :

C#
public interface IDrawable
{
void Dessiner();
}
Cette interface définit une méthode abstraite Dessiner(). Cette méthode doit être
implémentée par les classes concrètes qui implémentent l'interface IDrawable.
Conclusion

Les classes abstraites et les interfaces sont des concepts importants de la POO.
Elles peuvent être utilisées pour améliorer la modularité, la réutilisation et la
cohérence du code.