Etablissement Inter–Etats d’Enseignement Supérieur

CENTRE D’EXCELLENCE TECHNOLOGIQUE PAUL BIYA

BP 13719 Yaoundé (Cameroun) Tél. (237) 22 72 99 58 - Fax (237) 22 72 99 57
Site web : www.iaicameroun.com E-mail : contact@iaicameroun.com

Cours Initiation à la

Programmation

Orientée Objet
Contenu
Chapitre I : Introduction générale à la programmation orientée objet ......................................................3
Introduction ...........................................................................................................................................3
I. Historique des langages de programmation ......................................................................................3
II. De l'approche classique aux objets ..................................................................................................4
1. L'approche classique .....................................................................................................................4
2. L'approche objet ...........................................................................................................................5
III. Présentation des concepts liées à la programmation orientée objet................................................5
1. L’objet ..........................................................................................................................................5
2. La notion de classe .......................................................................................................................6
3. L’Encapsulation ............................................................................................................................7
4. L’Héritage (Spécialisation ou Généralisation) .............................................................................7
5. Le Polymorphisme ........................................................................................................................8
IV. Modélisation orientée objet et quelques langages de programmation orientée objet .....................8
1. Modélisation orientée objet ..........................................................................................................8
2. Quelques langages de programmation orientée objet ...................................................................9
Chapitre II : Les langages de programmation orientée objet ................................................................. 11
I. Introduction au langage java .......................................................................................................... 11
1. Environnement java ................................................................................................................... 11
2. Les caractéristiques du langage java.......................................................................................... 12
3. Les différentes éditions de Java ................................................................................................. 14
4. Les outils de base pour programmer en Java ............................................................................. 14
5. La structure générale d’un programme en Java ......................................................................... 17
II. Introduction au C++...................................................................................................................... 18
1. Introduction ............................................................................................................................... 18
2. Outils nécessaires pour développer en c++ ............................................................................... 18
3. Structure générale d’un programme en c++ .............................................................................. 19
III. Introduction au php 5 .................................................................................................................. 25
Chapitre III : Implémentation des concepts de la programmation orientée objet à l’aide d’exemples et
dans divers langages orientée objet........................................................................................................ 26
I. Les classes et les objets .................................................................................................................. 26
1. Application en Java ................................................................................................................... 26
a) Le concept d’objet ..................................................................................................................... 26

Page 1
 b) Le concept de classe .................................................................................................................. 26
c) La notion d’héritage .......................................................................................................................... 30
d) La notion de polymorphisme ............................................................................................................ 32
2. Application en C++ ........................................................................................................................... 33

Page 2
Chapitre I : Introduction générale à la programmation orientée objet

Introduction
Avant l’écriture d’un programme, il faut d’abord mettre au point un algorithme
de résolution du problème. Un algorithme étant une suite finie et ordonnée d’instructions
décrivant de façon exhaustive le processus de résolution d’un problème donnée dans un
intervalle de temps donné. Il (l’algorithme) exprime la structure logique d’un
programme informatique et de ce fait est indépendant du langage de programmation
utilisé. Par contre, la traduction de l’algorithme dans un langage particulier dépend du
langage choisi et sa mise en œuvre dépend également de la plateforme d’exécution.
Un programme quant à lui n’est rien d’autre qu’une suite d’instructions, encodées
en respectant de manière très stricte un ensemble de conventions fixées à l’avance par
un langage informatique. Il existe principalement deux types de programmations : la
programmation procédurale (ou structurelle) qui sépare les données des traitements et
la programmation orientée objet qui associe les données des traitements au sein d’un
même objet. Dans le cadre de ce cours, nous nous intéresserons à la programmation
orientée objet.

I. Historique des langages de programmation

Avant les années 1950, on programmait directement les ordinateurs en langage machine.
Un langage machine est une suite d’instructions codées sur des mots de 32 bits pour le
MIPS (million d’instructions par seconde mais ici il s’agit d’un microprocesseur). La
programmation n’étant pas évidente en langage machine, on a essayé d’améliorer le
travail du programmeur.
En premier lieu on a donné des informations symboliques appelées mnémoniques
aux instructions machines. Ce qui a donné naissance au langage assembleur. Ce langage
assembleur contient des instructions faisant intervenir les registres de l'unité centrale de
l'ordinateur ainsi que les données.
Ensuite on a introduit des étiquettes dans le langage d'assemblage dans le but de
faciliter les branchements conditionnels (boucles, sauts), cela a donné des instructions

Page 3
 de la forme BRANCH. Enfin on a exprimé directement des emplacements mémoires en
leur donnant un nom symbolique à la place de l’adresse en hexadécimal.
L’étape suivante a consisté à s’affranchir complètement de la machine en
élaborant ce que l’on appelle des langages de haut niveau à partir de 1950. Ces langages
ont introduit un certain nombre de constructions qui n’existent pas dans le langage
machine (expressions arithmétiques, les notions de variable, de procédure, de fonction
et des structures de données). Dès 1970 sont apparue des langages à objets qui ont
introduit à leur tour des notions de : Classes, objets, méthodes, variables d’instances,
l’héritage et le polymorphisme.

Or ces langages de haut niveau et à objets ne sont pas compris par l’ordinateur. Il a fallu
donc construire des programmes qui traduisent des énoncés exprimés dans ces langages
utilisés par les programmeurs en instructions pour la machine cible. De tels programmes
s’appellent des compilateurs ou des interpréteurs.

o L’interpréteur traduit les programmes instruction par instruction dans le cadre

d’une interaction continue avec l’utilisateur. Ainsi, le programme est traduit à chaque
exécution.
o Le compilateur traduit les programmes dans leur ensemble : tout le programme
doit être fourni en bloc au compilateur pour la traduction. Il est traduit une seule fois
dans l’optique de produire un exécutable.

II. De l'approche classique aux objets

1. L'approche classique

Le paradigme de la programmation structurée sépare les données des traitements. Les

données sont stockées dans des fichiers ou dans des bases de données. Les traitements
afférents à ces données sont des programmes dans un langage de programmation
structurée comme le C ou Cobol qui permettent d'accéder aux données et de les
manipuler.
Par exemple, un programme de gestion d'une bibliothèque dans une approche
classique verrait les différents ouvrages stockés dans des fichiers ou dans une base de

Page 4
 données et il existerait du code (C, Cobol, ...) permettant d'accéder aux données pour
emprunter, restituer, ... les livres.
Cet exemple peut être représenté de la façon suivante :

2. L'approche objet

Le paradigme objet est basé sur l'encapsulation des données et des traitements dans
une seule entité : l'objet. Un objet représente alors une entité du monde réel avec ses
données et ses traitements. L’une des particularités de cette approche est qu’elle
rapproche les données et leurs traitements associés au sein d’un unique objet.
Le fichier ou la bases de données contenant par exemple les ouvrages d'une bibliothèque
contiendra non seulement toutes les descriptions des ouvrages (les données) mais aussi
toutes les opérations qu'il est possible d'effectuer sur les ouvrages comme l'emprunt, le
retrait, ... (les traitements).

III. Présentation des concepts liées à la programmation orientée objet

1. L’objet
L’approche orientée objet considère le logiciel comme une collection d’objets
dissociés, identifiés et possédant des caractéristiques. Une caractéristique est soit un
attribut (i.e. une donnée caractérisant l’état de l’objet), soit une entité comportementale
de l’objet (i.e. une fonction). La fonctionnalité du logiciel émerge alors de l’interaction
entre les différents objets qui le constituent.
Comme nous venons de le dire, un objet est caractérisé par plusieurs notions :
L’identité ou le nom de l’objet – L’objet possède une identité, qui permet de le
distinguer des autres objets, indépendamment de son état. On construit généralement
cette identité grâce à un identifiant découlant naturellement du problème (par exemple
un produit pourra être repéré par un code, une voiture par un numéro de série, etc.)

Page 5
 Les attributs – Il s’agit des données caractérisant l’objet. Ce sont des variables
stockant des informations sur l’état de l’objet.
Les méthodes – Les méthodes d’un objet caractérisent son comportement, c’està-
dire l’ensemble des actions (appelées opérations) que l’objet est à même de réaliser. Ces
opérations permettent de faire réagir l’objet aux sollicitations extérieures (ou d’agir sur
les autres objets). De plus, les opérations sont étroitement liées aux attributs, car leurs
actions peuvent dépendre des valeurs des attributs, ou bien les modifier. Par exemple
une voiture d'immatriculation "1856VX80", de marque Renault, de modèle Mégane et
de puissance 7cv est un objet qui dispose de toutes les fonctions permettant de gérer son
comportement comme le changement d'immatriculation par exemple. Cet objet peut être
représenté de la façon suivante :

2. La notion de classe

Une classe est un type de données abstrait qui précise des caractéristiques
(attributs et méthodes) communes à toute une famille d’objets et qui permet de créer
(instancier) des objets possédant ces caractéristiques. L’objet est tout simplement
l’instance d’une classe. Tous les objets de même structure et de même comportement
sont regroupés dans des classes.
Par exemple, Ma voiture, la voiture de mon voisin, ... ont toutes les mêmes
caractéristiques, on peut donc les regrouper dans une classe Voiture dont la
représentation serait la suivante :

Page 6
 3. L’Encapsulation

L’encapsulation consiste à masquer les détails d’implémentation d’un objet, en

définissant une interface. L’interface est la vue externe d’un objet, elle définit les
services accessibles aux utilisateurs de l’objet.
L’encapsulation facilite l’évolution d’une application car elle stabilise
l’utilisation des objets : on peut modifier l’implémentation des attributs d’un objet sans
modifier son interface, et donc la façon dont l’objet est utilisé. L’encapsulation garantit
l’intégrité des données, car elle permet d’interdire, ou de restreindre, l’accès direct aux
attributs des objets. L’encapsulation est donc un moyen efficace, même s'il peut parfois
s'avérer plus lourd à mettre en place, de préserver l'intégrité des données.
Concrètement, toute tentative d'accès à des données protégées d'un objet depuis
l'extérieur de l'objet sans passer par les méthodes entraîne des erreurs de compilation.

4. L’Héritage (Spécialisation ou Généralisation)

L’héritage est un mécanisme de transmission des caractéristiques (ses attributs et

méthodes) d’une classe (classe mère ou classe parent) vers une sous-classe (classe fille).
Une classe peut être spécialisée en d’autres classes, afin d’y ajouter des caractéristiques
spécifiques ou d’en adapter certaines. Plusieurs classes peuvent être généralisées en une
classe qui les factorise, afin de regrouper les caractéristiques communes d’un ensemble
de classes. Ainsi, la spécialisation et la généralisation permettent de construire des
hiérarchies de classes. L’héritage évite la duplication et encourage la réutilisation.
Si l'on utilise encore l'exemple de la voiture, on peut généraliser ce cas en, disant que les
voitures et les poids lourds sont des véhicules qui ont des caractéristiques communes.
On peut alors créer par généralisation une classe Véhicule qui dispose des
caractéristiques communes (immatriculation, marque, modèle, …) et par spécialisation
deux sous-classes Véhicule et Poids lourd qui disposent chacune de leurs attributs
propres et qui héritent de la classe Véhicule. Ce cas peut être représenté de la façon
suivante :

Page 7
 5. Le Polymorphisme
Le polymorphisme représente la faculté d’une méthode à pouvoir s’appliquer à des
objets de classes différentes. Le polymorphisme augmente la généricité, et donc la
qualité, du code. Le polymorphisme représente aussi la capacité pour une classe de
définir plusieurs méthodes ayants le même nom mais qui diffèrent par les paramètres
(les arguments) en types et/ou en nombre.

IV. Modélisation orientée objet et quelques langages de programmation orientée objet

1. Modélisation orientée objet

Pour programmer une application, il ne convient pas de se lancer tête baissée dans
l’écriture du code : il faut d’abord organiser ses idées, les documenter, puis organiser la
réalisation en définissant les modules et étapes de la réalisation. C’est cette démarche
antérieure à l’écriture que l’on appelle modélisation ; son produit est un modèle.
Pourquoi modéliser ?
Modéliser un système avant sa réalisation permet de mieux comprendre le
fonctionnement du système. C’est également un bon moyen de maîtriser sa complexité
et d’assurer sa cohérence.
Un modèle est une représentation abstraite et simplifiée (i.e. qui exclut certains détails),
d’une entité (phénomène, processus, système, etc.) du monde réel en vue de le décrire,
de l’expliquer ou de le prévoir. Concrètement, un modèle permet de réduire la

Page 8
complexité d’un phénomène en éliminant les détails qui n’influencent pas son
comportement de manière significative. Il reflète ce que le concepteur croit important
pour la compréhension et la prédiction du phénomène modélisé.
Dans le domaine de l’ingénierie du logiciel, le modèle permet de mieux répartir les
tâches et d’automatiser certaines d’entre elles. C’est également un facteur de réduction
des coûts et des délais.
Les méthodes utilisées dans les années 1980 pour organiser la programmation
impérative (notamment Merise) étaient fondées sur la modélisation séparée des données
et des traitements. Lorsque la programmation par objets prend de l’importance au début
des années 1990, la nécessité d’une méthode qui lui soit adaptée devient évidente. Plus
de cinquante méthodes apparaissent entre 1990 et 1995 (Booch, Classe-Relation, Fusion,
HOOD, OMT, OOA, OOD, OOM, OOSE, etc.) mais aucune ne parvient à s’imposer.
En 1994, le consensus se fait autour de trois méthodes :
– OMT de James Rumbaugh (General Electric) fournit une représentation graphique
des aspects statique, dynamique et fonctionnel d’un système ;
– OOD de Grady Booch, définie pour le Department of Defense, introduit le concept
de paquetage (package) ;
– OOSE d’Ivar Jacobson (Ericsson) fonde l’analyse sur la description des besoins
des utilisateurs (cas d’utilisation, ou use cases).
Ce qui va donner naissance avec l’aide de l’OMG (Object Management Group) le
langage de modélisation UML (Unified Modeling Language).

2. Quelques langages de programmation orientée objet

L’orienté objet s’est trouvé à l’origine ces dernières années, d’une explosion de
technologies différentes, mais toutes intégrant à leur manière les mécanismes de base de
l’OO : classes, objets, héritage, encapsulation, polymorphisme... Ainsi sont apparus une
multitude de langages de programmation, qui intègrent ces mécanismes de base à leur
manière, à partir d’une syntaxe présentant parfois quelques différences. Les trois
principaux précurseurs sont : Simula, Smalltalk et C++.

Page 9
 En effet, Alan Kay, du PARC de Xerox, avait utilisé Simula dans les années 1960.
Il réalisa en 1976 Smalltalk qui reste, aux yeux de certains programmeurs, le meilleur
langage de programmation par objets.
Bjarne Stroustrup a mis au point C++, une extension du langage C permettant la
programmation orientée objets, aux Bell Labs d’AT&T en 1982. C++ deviendra le
langage le plus utilisé par les programmeurs professionnels. Il arrivera à maturation en
1986, sa standardisation ANSI / ISO date de 1997.
En plus des langages ci-dessus cités, il est apparu plusieurs autres langages de
programmation orientés objets, tels Eiffel, Java, C#, Delphi, Power Builder, Python,
PHP à partir de sa version 5.4.
Nous verrons de manière détaillée dans le cadre de ce cours quelques langages
programmation orientés objets tel que le Java, le C++ et le php5.

Page 10
 Chapitre II : Les langages de programmation orientée objet

I. Introduction au langage java

1. Environnement java

Java a été conçu par James Gosling en 1994 chez Sun Microsystems. L’idée était
d’avoir un langage de développement simple, portable, orienté objet et interprété. En
Janvier 2010, Sun est racheté par Oracle Corporation qui fournit dorénavant les outils
de développement Java SE (Standard Edition) contenus dans le Java Development Kit
(JDK). Java offre un ensemble de classes pour développer des applications de types très
variés (réseau, interface graphique, multi-tâches, etc.).

Java est un langage semi compilé et interprété, ce qui signifie qu’un programme
compilé n’est pas directement exécutable par le système d’exploitation mais il doit être
interprété par un autre programme, qu’on appelle interpréteur.

Un programmeur Java écrit son code source, sous la forme de classes, dans des
fichiers dont l’extension est .java. Ce code source est alors compilé par le compilateur
javac en un langage appelé bytecode et enregistre le résultat dans un fichier dont
l’extension est .class. Le bytecode ainsi obtenu n’est pas directement utilisable. Il doit
être interprété par la machine virtuelle de Java qui transforme alors le code compilé en
code machine compréhensible par le système d’exploitation. C’est la raison pour
laquelle Java est un langage portable : le bytecode reste le même quel que soit
l’environnement d’exécution. La figure suivante illustre ce fonctionnement.

Page 11
2. Les caractéristiques du langage java

Page 12
Page 13
 3. Les différentes éditions de Java

Trois plates-formes d'exécution (ou éditions) Java sont définies pour des cibles distinctes selon
les besoins des applications à développer :
➢ Java Standard Edition (J2SE / Java SE) : environnement d'exécution et
ensemble complet d'API pour des applications de type desktop. Cette plate-forme sert
de base en tout ou partie aux autres plates-formes
Java Enterprise Edition (J2EE / Java EE) : environnement d'exécution reposant
intégralement sur Java SE pour le développement et le déploiement des applications
serveur, Web services, etc.
➢ Java Micro Edition (J2ME / Java ME) : environnement d'exécution et API
pour le développement d'applications sur appareils mobiles et embarqués dont les
capacités ne permettent pas la mise en œuvre de Java SE.

La séparation en trois plates-formes permet au développeur de mieux cibler

l'environnement d'exécution et de faire évoluer les plates-formes de façon plus
indépendante.

4. Les outils de base pour programmer en Java

Le JDK (Java Development Kit en anglais, Kit de Développement Java en Français)

représente l’outillage indispensable au développeur Java. Ce kit contient les outils
nécessaires pour programmer, exécuter, tester et livrer ses programmes java à ses
clients. Un programmeur Java ne peut pas programmer sans JDK. En plus du jdk, on
peut si on le désire utiliser aussi les IDE (Integrated Development Environment) tel que
:
Netbeans, Eclipse...

Faire le TP1 et le TP2 : Installation et test du jdk et des IDE

➢ Télécharger puis installer une version du jdk (Exemple : ’jdk-8u11-windowsx64.exe’

si votre machine est une machine à processeur 64 bit.) ;

Page 14
 ➢ Analyser contenu et répertoires du jdk (Vérifiez l’arborescence de votre installation,
sous c :\Program Files\Java. Et le contenu du répertoire du jdk1.8.0_11) ;
➢ Pour permettre au système de reconnaître TOUS les outils présents dans le répertoire
’bin’, vous devez ajouter ce répertoire à la variable d’environnement ’PATH’ de
votre ordinateur. (Cliquez droit sur l’icône ’Ordinateur’ et sélectionnez ’propriétés’
dans le menu contextuel puis cliquez sur le lien ’paramètres systèmes avancés’.) ;
➢ Cliquez sur le bouton ’variable d’environnement’. Vous obtenez la fenêtre des
variables d’environnement, contenant une partie ’user’ et une partie ’système’.
➢ Dans la partie ’user’, cliquez sur ’nouveau’. Ajoutez une nouvelle variable PATH et
associez la valeur suivante : C :\Program Files\Java\jdk1.8.0_11\bin ;%Path% . En
suite valider.
➢ Tester de l’installation à partir de l’invite de commande (Lancez la commande :
javac. Ensuite Lancez l’instruction (la commande) : java)

Java est désormais parfaitement installé sur votre ordinateur !

Selon sa version, le JDK contient un certain nombre de packages, chacun étant
constitué par un ensemble de classes qui couvrent un même domaine et apportent de
nombreuses fonctionnalités. Ci-après, une liste non exhaustive de packages de bases :

Page 15
Page 16
 5. La structure générale d’un programme en Java
Un programme Java est constitué d’un ou plusieurs fichiers source. Chaque fichier source
peut contenir, dans l’ordre :

Exemple1 :
public class TestBonjour
{
public static void main(String[] args)
{
System.out.println("Bonjour");
}
}
Exemple 2 :

Page 17
II. Introduction au C++
1. Introduction
Apparu au début des années 90, le langage C++ est actuellement l’un des plus utilisés
dans le monde, aussi bien pour les applications scientifiques que pour le développement
des logiciels. En tant qu’héritier du langage C, le C++ est d’une grande efficacité. Mais
il a en plus des fonctionnalités puissantes, comme par exemple la notion de classe, qui
permet d’appliquer les techniques de la programmation-objet.

2. Outils nécessaires pour développer en c++

Pour programmer en c++, Voici le strict minimum d’outils pour un programmeur :

• Un éditeur de texte pour écrire le code source du programme en C++. En théorie un
logiciel comme le Bloc-Notes sous Windows ou vi sous Linux fait l'affaire
• Un compilateur pour transformer (« compiler ») votre code source en binaire.
Page 18
 • Un débugger (« Débogueur » ou « Débugueur » en français) pour vous aider à
traquer les erreurs dans votre programme.
Deux possibilités s’offrent aux programmeurs :
• Soit on récupère chacun de ces 3 programmes séparément. C'est la méthode la plus
compliquée, mais elle fonctionne. Sous Linux en particulier, bon nombre de
programmeurs préfèrent utiliser ces 3 programmes séparément.
• Soit on utilise un programme qui combine éditeur de texte, compilateur et débugger.
Ces programmes sont appelés IDE. Il existe plusieurs environnements de
développement.

3. Structure générale d’un programme en c++

Exemples de programme C++ avec l’approche procédurale

Page 19
Page 20
Page 21
Exemple 2 :

Page 22
Page 23
Exemple de programme C++ avec l’approche orientée objet

Page 24
Page 25
 Chapitre III : Implémentation des concepts de la programmation orientée objet à l’aide
d’exemples et dans divers langages orientée objet

I. Les classes et les objets

1. Application en Java

a) Le concept d’objet

Un objet est une instance d'une classe. Il est nécessaire de définir la déclaration d'une variable
ayant le type de l'objet désiré.

L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable.La

déclaration est de la forme :
nom_de_classe nom_de_variable = new nom_de_classe() ;
La variable this sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. this
est un objet qui est égal à l'instance de l'objet dans lequel il est utilisé

b) Le concept de classe

Une classe est un ensemble de données et de fonctions regroupées dans une même entité.
Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les
données sont appelées des méthodes. Instancier une classe consiste à créer un objet sur
son modèle. Pour accéder à une classe il faut en déclarer une instance de classe ie l’objet.
Une classe comporte dans sa déclaration, des variables et les définitions de ses
méthodes. Une classe se compose de deux parties : l’en-tête et le corps. Le corps peut
être divisé en 2 sections : la déclaration des données et des constantes et la définition
des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui
gèrent leur accessibilité par les composants hors de la classe. La syntaxe de déclaration
d'une classe est la suivante :

Page 26
➢ Les attributs de classes

Page 27
➢ Les méthodes de classes

Page 28
Page 29
 c) La notion d’héritage

➢ Déclaration d’implémentation d’interface

Page 30
Page 31
d) La notion de polymorphisme

Page 32
2. Application en C++

Page 33
Page 34
Page 35
Page 36
Page 37
Page 38
Page 39
Page 40
Page 41
Page 42
Page 43
Page 44
Page 45
Page 46
Page 47
Page 48
Page 49
Page 50
Page 51
Page 52
Page 53