Académique Documents
Professionnel Documents
Culture Documents
DEDICACE
INFO-GROUPE 3-2122
i
JAVA ET PROGRAMMATION ORIENTEE OBJET
REMERCIEMENTS
Nous tenons à remercier toutes les personnes qui, d’une façon ou d’une autre ont œuvré
pour la concrétisation de ce travail. Il s’agit de :
INFO-GROUPE 3-2122 ii
ii
JAVA ET PROGRAMMATION ORIENTEE OBJET
RESUME
Les travaux effectués dans le cadre de notre exposé avaient pour objectif principal
d’introduire les concepts de base du langage java et la Programmation Orientée Objet. Cette
présentation traite principalement les thèmes tels que : encapsulation, héritage, polymorphisme
ainsi que les notions de base de la Programmation Orientée Objet : les classes, les objets, les
méthodes, l’héritage multiple, la notion de visibilité, etc. Toute fois pour une meilleure
compréhension de ces concepts nous les avons implémentés dans un programme qui détermine le
nombre de parpaings nécessaire à la construction d’un mur de dimension donnée. Il en ressort
que le langage java est clairement défini de par ses concepts et les syntaxes respectives de ces
derniers.
iii
JAVA ET PROGRAMMATION ORIENTEE OBJET
ABSTRACT
The main objective of the work carried out within the framework of our presentation was to
introduce the basic concepts of the java language and Object Oriented Programming. This
presentation mainly deals with themes such as: encapsulation, inheritance, polymorphism as well
as the basic notions of Object Oriented Programming: classes, objects, methods, multiple
inheritance, the notion of visibility, etc. However for a better understanding of these concepts we
have implemented them in a program which determines the number of concrete blocks necessary
for the construction of a wall of given size. It turns out that the java language is clearly defined
INFO-GROUPE 3-2122 iv
iv
JAVA ET PROGRAMMATION ORIENTEE OBJET
INFO-GROUPE 3-2122 v
v
JAVA ET PROGRAMMATION ORIENTEE OBJET
REMERCIEMENTS.......................................................................................................................ii
RESUME........................................................................................................................................iii
ABSTRACT...................................................................................................................................iv
INTRODUCTION...........................................................................................................................1
A. Notion d’objet...................................................................................................................2
1. Définition..........................................................................................................................2
2. Syntaxe..............................................................................................................................2
3. Exemple d’utilisation........................................................................................................3
B. Notion de classe................................................................................................................3
1. Définition..........................................................................................................................3
2. Syntaxe..............................................................................................................................4
3. Exemple d’utilisation........................................................................................................5
C. Notion d’encapsulation.....................................................................................................5
1. Concept d’encapsulation...................................................................................................5
2. Niveau de visibilité...........................................................................................................5
D. Notion d’héritage..............................................................................................................6
1. Définition..........................................................................................................................6
2. Hiérarchie de classes.........................................................................................................6
3. Héritage multiple...............................................................................................................6
E. Notion de méthode................................................................................................................7
INFO-GROUPE 3-2122 vi
vi
JAVA ET PROGRAMMATION ORIENTEE OBJET
1. Définition..........................................................................................................................7
F. Notion de polymorphisme..................................................................................................11
1. Définition........................................................................................................................11
2. Type de polymorphisme..................................................................................................11
A. Enoncé.............................................................................................................................14
B. Code en java....................................................................................................................14
Conclusion.....................................................................................................................................20
Références bibliographiques........................................................................................................viii
vii
JAVA ET PROGRAMMATION ORIENTEE OBJET
INTRODUCTION
Le Java est un langage orienté objet dont la syntaxe repose sur la syntaxe du langage C et
C++. Le nom « Java » veut dire « café » (en argot américain). Il a été choisi en remplacement du
nom d'origine « Oak », à cause d'un conflit avec une marque existante. Le logo choisi par Sun est
d'ailleurs une tasse de café fumant.
La programmation orientée objet, pour sa part, tourne autour d'une unique entité, à savoir
l'objet. Un objet est une structure de données qui regroupe les données et les moyens de
traitement de ces données.
L’un des plus importants langages, supportant les éléments de la Programmation Orientée
Objet est bien entendu le langage Java. Java est un langage de programmation mis au point par
Sun Microsystems (rachetée par Oracle en 2010) qui permet d’implémenter des logiciels
indépendants de toute architecture matérielle.
Dans la suite, nous présenterons les notions de base de la programmation orientée objet,
leur syntaxe en langage JAVA le cas échéant ainsi que des illustrations.
INFO-GROUPE 3-2122
1
JAVA ET PROGRAMMATION ORIENTEE OBJET
La programmation orientée objet est caractérisée par un ensemble de concepts tels que l’objet, la
classe, l’encapsulation, l’héritage et le polymorphisme.
A. Notion d’objet
1. Définition
Un objet est une entité informatique qui modélise un élément du monde réel. Cette entité
permet alors de regrouper les principales caractéristiques d’un élément du monde réel (taille,
couleur, ...). La difficulté de cette modélisation consiste à créer une représentation abstraite, sous
forme d'objets, des entités ayant une existence matérielle (chien, voiture, ampoule, ...) ou bien
virtuelle (temps, espace ...). Un objet est caractérisé par plusieurs notions :
Les attributs : Il s'agit des données caractérisant l'objet. Ce sont des variables stockant des
informations d'état de l'objet ;
Les méthodes (appelées parfois fonctions membres) : Les méthodes d'un objet
caractérisent son comportement, c'est-à-dire l'ensemble des actions (appelées opérations)
que l'objet peut réaliser. Ces opérations permettent de faire réagir l'objet selon des
invocations extérieures (ou d'agir sur les autres objets). De plus, les opérations sont
fortement liées aux attributs, car leurs actions peuvent dépendre des valeurs des attributs,
ou bien peuvent les modifier ;
L'identité : 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 matricule, ...).
2. Syntaxe
Pour instancier un objet d’une classe, on fait un appel explicite à l’opérateur new en
précisant la classe à instancier. Un objet est donc une instance d’une classe.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Cette référence doit être mémorisée dans une variable (référence) pour pouvoir accéder à l’objet
créé.
3. Exemple d’utilisation
Pour initialiser l’objet t créé au-dessus avec une hauteur 3 et une base 4, on peut écrire :
B. Notion de classe
1. Définition
On appelle classe la définition de la structure d'un objet, c'est à -dire la déclaration de l'ensemble
des objets qui ont des mêmes caractéristiques. En réalité, on dit qu'un objet est une instanciation
d'une classe. On parle donc d'objet ou d'instance (éventuellement d'occurrence). Une classe est
composée de deux parties :
Les attributs (parfois appelés données membres) : il s'agit des données représentant l'état de
l'objet.
Les méthodes (parfois appelées fonctions membres) : il s'agit des opérations applicables aux
objets.
La définition d’un nouveau type de données, d’une façon générale, se fait en Java en utilisant les
classes. Une classe comporte des attributs et des méthodes. En Java, on ne peut écrire des
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
algorithmes que comme méthodes d’une classe. On peut dire que : Classe = attributs +
Méthodes.
Si on définit la classe voiture, les objets Peugeot 406, Renault 18 seront des instanciations de
cette classe.
Bicyclette
Taille de cadre
Abstraction Taille de roues Attributs
Vitesse
Conduire Méthodes
Polygone
Abstraction
Arrête
Couleur de fond Attributs
Dessiner Méthodes
2. Syntaxe
Modificateur Rôle
La classe contient une ou des méthodes abstraites, qui n'ont pas de définition
explicite. Une classe déclarée abstract ne peut pas être instanciée : il faut définir
abstract
une classe qui hérite de cette classe et qui implémente les méthodes nécessaires
pour ne plus être abstraite.
La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite.
final
Les classes déclarées final ne peuvent donc pas avoir de classes filles.
Private la classe n'est accessible qu'à partir du fichier où elle est définie
public La classe est accessible partout
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
3. Exemple d’utilisation
Pour définir la classe Triangle avec 2 attributs et une méthode surface, on peut écrire :
class Triangle ;
// Attributs de la classe
double surface()
C. Notion d’encapsulation
1. Concept d’encapsulation
2. Niveau de visibilité
L'encapsulation permet de définir des niveaux de visibilité des éléments de la classe. Ces
niveaux de visibilité définissent les droits d'accès aux données. Il existe trois niveaux de
visibilité:
Publique : les fonctions de toutes les classes peuvent accéder aux données ou aux méthodes
d'une classe définie avec le niveau de visibilité public. Il s'agit du plus bas niveau de protection
des données.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Protégée : l'accès aux données est réservé aux fonctions des classes héritières, c'est-à-dire par
les fonctions membres de la classe, ainsi que les fonctions des classes dérivées.
Privée : l'accès aux données est limité aux méthodes de la classe elle-même. Il s'agit du niveau
de protection des données le plus élevé.
D. Notion d’héritage
1. Définition
2. Hiérarchie de classes
Animal
3. Héritage multiple
L’héritage multiple offre la possibilité de faire hériter une classe de deux superclasses.
Ainsi, cette technique permet de regrouper au sein d'une seule et même classe, les attributs et
méthodes de plusieurs classes.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Animal
Herbivore Carnivore
Omnivore
E. Notion de méthode
1. Définition
Une méthode est une fonction faisant partie d'une classe. Elle permet d'effectuer des
traitements sur (ou avec) les données membres des objets. Puisqu'en Java on ne manipule que des
classes, il n'y aura formellement que des méthodes, même si on pourra parler de fonction pour
des méthodes static qui ne manipulent aucune des données membres.
-Le constructeur par défaut appelé par défaut lors de la création d'un objet, (offert par
défaut lors de la compilation s'il n'y a pas de constructeur déclaré).
-Le constructeur par recopie (ou constructeur de copie) appelé lors de la création de
l'objet, du passage d'un objet par référence.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Les accesseurs permettent de récupérer la valeur de données membres privées sans y accéder
directement de l'extérieur ; ils sécurisent donc l'attribut en restreignant sa modification,
Les mutateurs permettent de modifier l'état de données membres tout en vérifiant si la valeur que
l'on veut donner à la donnée membre respecte les normes de celle-ci ou diverses règles de
cohérence. Leur détournement pour modifier en cascade d'autres états du programme pouvant
être source de bogues ou de perte de maintenabilité.
Avant d'être utilisée, une méthode doit être définie car pour l'appeler dans une classe il
faut que le compilateur la connaisse, c'est-à-dire qu'il connaisse son nom, ses arguments et les
instructions qu'elle contient. La définition d'une méthode s'appelle Déclaration. La déclaration
d'une fonction se fait selon la syntaxe suivante :
Remarques:
- Type de retour représente le type de valeur que la méthode va retourner, cela peut-être un type
primitif, une classe, ou alors le mot-clé void si la méthode ne retourne aucune valeur.
- Le nom de la méthode suit les mêmes règles que les noms de variables : il doit être écrit en
minuscule, sauf pour les initiales de chaque nouveau mot.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
- Un nom de méthode peut comporter des chiffres, mais pas pour le premier caractère.
- Le nom de la méthode est sensible à la casse (différence entre les minuscules et majuscules) ;
- Les arguments sont facultatifs, mais s'il n'y a pas d'arguments, les parenthèses doivent rester
présentes.
Une fois cette étape franchie, votre méthode ne s'exécutera pas tant que l'on ne fait pas appel à
elle quelque part dans la classe !
Remarques
- Si vous exécutez une méthode sur l'objet courant (this), c'est à dire que vous utilisez dans une
classe, une méthode de la même classe, alors il est inutile de préciser que this est l'objet auquel
s'applique la méthode.
- Le point-virgule signifie la fin d'une instruction pour distinguer les différents blocs
d'instructions.
- Si jamais vous avez défini des arguments dans la déclaration de la méthode, il faudra veiller à
les inclure lors de l'appel de la méthode (le même nombre d'arguments séparés par des
virgules !), mais sans avoir à préciser leur type.
Il est possible de passer des arguments (appelés aussi paramètres) à une méthode, c'est-à-dire lui
fournir une valeur ou le nom d'une variable afin que la méthode puisse effectuer des opérations
sur ces arguments ou bien grâce à ces arguments.
Le passage d'arguments à une méthode se fait au moyen d'une liste d'arguments (séparés par des
virgules) entre parenthèses suivant immédiatement le nom de la méthode.
Un argument peut être : une constante, une variable, une expression, une autre méthode
retournant une valeur.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
La méthode peut renvoyer une valeur (et donc se terminer) grâce au mot-clé return. Lorsque
l'instruction return est rencontrée, la méthode évalue la valeur qui la suit, puis la renvoie au
programme appelant (classe à partir de laquelle la méthode a été appelée).
Une méthode peut contenir plusieurs instructions return, ce sera toutefois la première instruction
return rencontrée qui provoquera la fin de l'exécution de la méthode et le renvoi de la valeur qui
la suit.
return valeurDeRetour;
Le type de valeur retourné doit correspondre à celui qui a été précisé dans la définition
- La surcharge de méthode : Un des apports les plus intéressants de la conception objet, est la
possibilité d'appeler plusieurs méthodes avec le même nom, à condition que leurs arguments
diffèrent (en type et/ou en nombre).
Ce principe est appelé surcharge de méthode. Il permet de donner le même nom à des méthodes
comportant des paramètres différents et simplifie donc l'écriture de méthodes sémantiquement
similaires sur des paramètres de types différents. En effet, une méthode est déterminée par ce que
l'on appelle sa signature, c'est-à-dire : sa classe d'appartenance, son nom, ses paramètres.
Il est ainsi possible de définir une méthode réalisant la même opération sur des variables
différentes en nombre ou en type :
Return p1+p2;
Return p1+p2+p3;
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
{Return p1+p2 ;}
F. Notion de polymorphisme
1. Définition
Le nom polymorphisme vient du grec et signifie qu’une chose peut prendre plusieurs
formes. C’est une caractéristique essentielle de la programmation orientée objet. On distingue
généralement trois types de polymorphisme :
2. Type de polymorphisme
Nous allons maintenant tenter de définir plus précisément tout cela, mais il est important
de noter que beaucoup de confusions existent lorsqu'il s'agit de différencier tous ces types de
polymorphisme.
a) Le polymorphisme ad hoc
Le polymorphisme ad hoc permet d'avoir des fonctions de même nom, avec des
fonctionnalités similaires, dans des classes qui n’ont aucun rapport entre elles. Par exemple, la
classe complexe, la classe image et la classe lien peuvent avoir chacune une fonction "afficher".
Cela permettra de ne pas avoir à se soucier du type de l'objet que l'on a, si on souhaite l'afficher à
l'écran.
b) Le polymorphisme d’héritage
Le polymorphisme d’héritage permet de redéfinir une méthode dans des classes héritant
d'une superclasse. Imaginons un jeu d'échec comportant des objets roi, reine, fou, cavalier, tour
et pion, héritant chacun de l'objet pièce. La méthode mouvement pourra, grâce au
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
c) Le polymorphisme paramétrique
Le polymorphisme paramétrique permet de définir plusieurs fonctions de même nom,
mais possédant des paramètres différents (en nombre et/ou en type). On peut par exemple définir
plusieurs méthodes homonymes addition () effectuant une somme de valeurs.
etc.
On appelle signature le nombre et le type des arguments d'une fonction. C'est donc la
signature d'une méthode qui détermine quelle méthode sera appelée.
Quand on crée plusieurs instances (objets) d’une même classe, chaque instance possède
ses propres valeurs pour chacun de ses attributs. Dans le cas des attributs statiques (précédés par
le mot clé static), il n’existe qu’une seule copie de l’attribut dans la mémoire pour tous les objets
de la classe : l’attribut est rattaché à la classe elle-même et non pas à ses instances. Par
conséquent, tous les objets partagent la même valeur pour l’attribut, et si un seul objet modifie
cette valeur, elle sera modifiée pour tous les objets de cette classe.
Le mot clé static peut aussi précéder une méthode. Les méthodes statiques vérifient le
même principe que les attributs statiques. Il n’en existe qu’une seule copie par classe, c’est une
méthode de la classe plutôt que de ses instances. Par construction, une méthode statique ne peut
avoir accès qu’aux éléments (attributs et méthodes) statiques d’une classe. Pour appeler une
méthode statique d’une classe, on utilise en général le nom de la classe plutôt qu’une de ses
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
instances. Cela évite d’avoir à appeler le constructeur de la classe et de construire une instance.
L’intérêt des méthodes statiques est en effet de pouvoir être appelées alors qu’on ne dispose pas
d’un objet de la classe dans laquelle elle est définie.
Le mot clé static a le même rôle que le mot clé final utilisé pour la définition des attributs
constants. La différence est que pour un constant, la copie de l’attribut est dupliquée autant de
fois qu’une nouvelle instance est créée. Pour une optimisation d’espace, le mot clé final est
souvent utilisé avec le mot clé static pour déclarer un attribut constant, par exemple : public
static final int x = 7 ; Dans le cas d’une méthode, final indique que les classes qui héritent de la
classe dans laquelle cette méthode est définie ne peuvent pas redéfinir cette méthode. Les sous-
classes doivent utiliser cette méthode telle qu’elle est.
La déclaration d’une variable se traduit par la réservation d’un emplacement mémoire qui
sert à stocker la valeur de cette variable. Par exemple, l’instruction int a = 1 ; réserve un
emplacement mémoire de taille suffisante pour stocker un entier, puis dépose la valeur 1 dans cet
emplacement mémoire. Le mécanisme est le même pour tous les types de base.
Le mot clé this contient la référence à l'objet actuel. Le paramètre (mot clé) this est
implicitement présent dans chaque objet instancié.
Nous avons montré comment un programme Java manipule des références sur des
emplacements mémoire dans lesquels sont stockés des objets. Tous ces objets sont construits par
une allocation dynamique en invoquant l’instruction new. Se pose alors le problème de la
libération de la mémoire ainsi allouée. En Java l’outil qui s’occupe de la libération automatique
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
de l’espace mémoire s’appelle le "garbage collector", que l’on traduit en français par "ramasse-
miettes".
Données d’entrées :
Données de sortie :
B. Code en java
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Figure 5 : Résultat du programme pour un ce mur construit à l’aide des parpaings de 10
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Conclusion
La programmation classique sépare les données des traitements, rendant ainsi difficile la
mise en place de contrôles, destinés à garantir la cohérence et l’intégrité des données.
L’utilisateur peut en effet accéder directement aux données, sans utiliser les fonctions mises à sa
disposition. La programmation orientée objet a été introduite afin de remédier à ces
inconvénients en regroupant au sein d’une même unité, dite objet, les données et les traitements.
Java met encore à la disposition des développeurs une API (Application Programming
Interface) très riche, lui permettant de faire de très nombreuses choses. Ce langage propose à peu
près tout ce dont on a besoin directement dans le JDK. De plus il existe d’autres API pour des
fonctionnalités qui viendraient à manquer au JDK.
En plus des API, la notion des Plugins (modules d’extension) offerte par les éditeurs
Java, donnent à ce langage beaucoup d’avantages : rapidité, sécurité, fiabilité, portabilité,
robustesse et richesse des API.
Java, notamment via ses éditeurs Eclipse et NetBeans, offre des plugins intégrés, tels que
ADT (Android Development 79 Tools), pour la programmation mobile. Java est le principal
langage utilisé pour développer des applications pour le système d'exploitation libre Android de
Google pour les appareils Mobiles.
INFO-GROUPE 3-2122
JAVA ET PROGRAMMATION ORIENTEE OBJET
Références bibliographiques
A-Bibliographie :
B-Documents électroniques :
INFO-GROUPE 3-2122
viii