République Tunisienne

Ministère de l’Enseignement Supérieur

Institut Supérieur des Etudes Technologiques de Nabeul

Support de cours

_________________________________

PROGRAMMATION ORIENTEE OBJETS

____________________

Niveau : Troisième niveau de la section informatique

Option : Informatique Industrielle

Réalisé par : SGHAIER Imene

Année Universitaire : 2007-2008

 Table des Matières
INTRODUCTION A LA POO ....................................................................................................................................................1
0.1 Rappel : Les Types Abstraits de données................................................................................................................1
0.2 Exemple : concept POO ............................................................................................................................................2
CONCEPTS DE BASE DE LA POO .........................................................................................................................................4
1.1 De la programmation classique vers la programmation orientée objet .............................................................4
1.2 Définitions ....................................................................................................................................................................5
LES CONCEPTS ORIENTES OBJETS EN JAVA...............................................................................................................10
2.1 Notion de Classe........................................................................................................................................................10
2.2 Attributs et Méthodes ...............................................................................................................................................12
2.3 Objets et Instanciation..............................................................................................................................................17
2.4 Membres statiques et Autres mots clés (final, this, null) ....................................................................................22
2.6 Les packages ...............................................................................................................................................................26
3.1 L’encapsulation ..........................................................................................................................................................29
3.2 Modificateurs de visibilité et Accès ........................................................................................................................29
3.3 Surcharge des Méthodes...........................................................................................................................................33
L’HERITAGE .................................................................................................................................................................................38
4.1 Le principe de l'héritage............................................................................................................................................38
4.3 L'accès aux propriétés héritées ................................................................................................................................40
4.4 Construction et initialisation des objets dérivés...................................................................................................42
4.5 Dérivations successives ............................................................................................................................................44
4.6 Redéfinition et surcharge de membres .................................................................................................................44
4.7 Autres mots clés «final » et « super »....................................................................................................................47
4.8 Des conseils sur l'héritage ........................................................................................................................................48
LE POLYMORPHISME...............................................................................................................................................................49
5.1 Concept de polymorphisme.....................................................................................................................................49
5.2 Exemples et interprétations .....................................................................................................................................49
5.3 Conversion des arguments effectifs .......................................................................................................................52
5.4 Les conversions explicites de références ...............................................................................................................53
CLASSES ABSTRAITES ET INTERFACES ..........................................................................................................................57
6.1 Les classes abstraites .................................................................................................................................................57
6.2 Les interfaces..............................................................................................................................................................60
 Présentation du cours

Ce cours est conçu comme une introduction aux paradigmes de la programmation orientée objet. Il
présente les notions de base de cette technologie : type abstrait de données, classe, objet, héritage simple et
multiple, objet complexe. Mécanisme d’abstraction, surcharge, généricité, polymorphisme. Les concepts
seront illustrés avec le langage JAVA.
Niveaux cibles :
Étudiants du niveau 3, toutes filières (Réseaux Informatique, Informatique de gestion, informatique
industrielle)
Pré-requis :
Algorithmique, Structures de données, Programmation I et Programmation II
Formule pédagogique :
 Exposé informel
 Laboratoire
Moyens pédagogiques :
 Tableau
 Support de cours
Méthodologie :
 Cours intégré
 Travaux dirigés (réalisation et correction d’exercices)
 Travaux pratiques (JDK 1.5 + console MS-DOS)
Volume Horaire :
 22.5 heures de cours
 45 heures de travaux pratiques

Objectifs généraux :

 Comprendre les origines et l’intérêt d’un nouveau style de programmation orientée objet
 Maîtriser les concepts orientés objet en termes de définitions, syntaxe Java et usage
 Savoir utiliser cette nouvelle approche pour modéliser des problèmes
 Faire la liaison entre les différents éléments du cours (classes, objets, encapsulation,
héritage, polymorphisme, classe abstraite et les interfaces)
 Traiter la gestion des exceptions afin de permettre une production du code efficace
 Objectifs généraux Conditions de réalisation de la Critères d’évaluation de la
performance performance
1- S’initier aux concepts orientés A partir des notes du cours, des travaux Aucune confusion entre les
objets et leurs intérêts pratiques. dirigés et des références principes de la
bibliographiques, l’étudiant doit être programmation classique et
capable de dégager les lacunes de la programmation objet
l’approche classique de programmation
et de distinguer les principales
caractéristiques de POO
2- Comprendre les concepts A partir des notes du cours, des travaux Les exercices relatifs à
orientés objet en termes de dirigés et des références l’implémentation d’une
concept, syntaxe Java et bibliographiques, l’étudiant doit être classe en Java doivent être
utilisation. capable de concevoir des classes et des réussis
objets en Java
3- Comprendre l’utilité et A partir des notes du cours, des travaux Les exercices relatifs à l’accès
l’application des concepts dirigés et des références aux membres privés doivent
d’encapsulation et de surcharge. bibliographiques, l’étudiant doit être maîtrisés
maîtriser les concepts d’encapsulation et
surcharge
4- Comprendre la technique A partir des notes du cours, des travaux Aucune erreur n’est permise
d’héritage et ses intérêts dirigés et des références au niveau de la définition et
pratiques bibliographiques, l’étudiant doit être la manipulation d’une classe
capable de concevoir et implémenter des dérivée
classes dérivées.

5- Comprendre le concept de A partir des notes du cours, des travaux Aucune erreur n’est permise
polymorphisme et ses intérêts dirigés et des références au niveau de la liaison entre
pratiques bibliographiques, l’étudiant doit l’héritage et le
comprendre l’intérêt pratique de polymorphisme
polymorphisme et la relation avec
l’héritage
6- Comprendre et distinguer A partir des notes du cours, des travaux Aucune confusion entre les
entre les 2 concepts de classes dirigés et des références 2 concepts n’est permise
abstraites et interfaces bibliographiques, l’étudiant doit
comprendre l’utilité pratique des classes
abstraites et interfaces et distinguer les
nuances entre ces 2 concepts
7- Faire découvrir la notion de A partir des notes du cours, des travaux Les exercices relatifs à
gestion des exceptions dirigés, l’étudiant doit comprendre l’implémentation des
l’utilité pratique des exceptions. mécanismes des exceptions
en Java doivent être réussis

Évaluation : 1 test, 1 DS et un examen final écrits.

Nature Contenu Pourcentage Date

évaluation (environ)

Semaine 1 à 4 Semaine 1 à 4
Test ou 10% ou
Semaine 8 à 15 Semaine 8 à
15

Devoir Semaine 1 à 8 30% Semaine 8

surveillé

Note TP Semaine 2 à 14 30% Semaine 15

Examen Semaine 1 à 15 40% Semaine 16

Bibliographie :
 http://java.sun.com
 Lemay L, Le Programmeur JAVA 2, Campus Press.
 Bailly C, Chaline J.F., Ferry H.C & al, Les langages orientés objets, Cepadues éditions.
 POO – INTRODUCTION A LA POO

CHAPITRE 0 :

INTRODUCTION A LA POO

Objectif spécifique
 Rappel sur les types abstraits de données

Eléments de contenu
I. Rappel : les types abstraits de données
II. Exemple : comment penser en OO

Volume Horaire :
Cours : 1 heure 30
TD : 0 heure

0.1 Rappel : Les Types Abstraits de données

0.1.1 Définition :

Un type de données abstraites (TDA) peut être représenté comme l’abstraction sur les techniques de
représentation des données : fonctionnalité (opérations) avant tout. On peut dire qu’un TDA est constitué
d’un modèle mathématique et les opérations définies sur ce modèle.

Généralement, nous voulons construire des algorithmes en termes de TDA, mais la mise en œuvre d’un
algorithme dans un langage de programmation nécessite que nous trouvions un moyen de représenter les
TDA à l’aide des types de données et des opérations prédéfinis dans le langage lui-même. Pour représenter
le modèle mathématique sous jacent à un TDA : il faut recourir à des structures de données, qui sont des
ensembles de variables, à priori de types différents, reliées de multiples façons.
L’incarnation d’un TDA est la traduction, dans les termes d’un langage de programmation, la déclaration
qui définit une variable comme appartenant à ce type de données abstrait, et l’écriture dans un même
langage d’une procédure pour chaque opération relative à un TDA.
Une incarnation nécessite le choix d’une structure de données pour représenter le TDA : chaque structure
de donnée est construite à partir de types prédéfinis du langage de programmation hôte, à l’aide de ses
possibilités de structuration des donnés.
Par exemple les tableaux (array) et les enregistrements (record) sont deux outils particulièrement
importants en Pascal.

Mlle I.Sghaier - 1
 POO – INTRODUCTION A LA POO

En réalité, tout informaticien utilise déjà les TADs, parfois sans le savoir. En effet, dans un algorithme il
doit manipuler des nombres entiers ou réels, il ne se préoccupe pas de la représentation de ces nombres,
mais uniquement des propriétés intrinsèques des quatre opérations habituelles (+,-,*,/).
On présente ici par l’exemple la spécification d’un type bien connu, celui des booléens : le TDA booléen.

0.2 Exemple : concept POO

Consigne : on veut faire un programme de gestion du personnel d’une entreprise informatique. On y

trouve des ingénieurs, des techniciens, des directeurs et des ouvriers d’entretiens (concierge, femme de
ménage…).
1ère solution : Programmation procédurale classique => Que veut on faire ?
Struct ingénieur Nom
Prénom lecture-ingénieur()
Salaire affiche-ingénieur()
Type
Num-telephone Donnée : attributs du type calc-salaire()
Date-embauche
Liste-diplomes
Spécialité

Struct technicien Nom

Prénom lecture-technicien()
Salaire affiche-technicien()
Num-téléphone calc-salaire()
Date-embauche
Spécialité

Mlle I.Sghaier - 2
 POO – INTRODUCTION A LA POO

Laboratoire

Struct directeur Nom lecture-directeur()

Prénom affiche-directeur()
Salaire calc-salaire()
Num-téléphone
Num-fax
Num-bureau
Service

2 ème solution : Programmation orientée objet => De quoi parle-t-on ?

classe Personnel Nom de la classe

Nom
Prénom Attributs de la classe
Salaire
Num-telephone
Lecture-pers()
Afficher-pers() Méthodes de la classes
affiche-ingénieur()

Classe Ingénieur classe Technicien classe Directeur

Date-embauche Date-embauche Numero-fax

Spécialité Spécialité num-bureau
Listes-diplomes laboratoire Service
Lecture-ingen() lecture-technicien() lecture-direct()
Affch-ingen() Affiche-technicien() affiche-directeur()
Calc-sal-Ingen() Calc-salaire-techn() calc-salaire-sirect()

Mlle I.Sghaier - 3
 POO – CONCEPTS DE BASE DE LA POO

CHAPITRE 1 :

CONCEPTS DE BASE DE LA POO

Objectifs spécifiques
 Introduire les facteurs de naissance de la POO
 Introduire la définition de la POO
 Introduction au concept de l’approche OO

Eléments de contenu
I. De la programmation classique vers la POO
II. Définition
III. Concepts de base de la POO

Volume Horaire :
Cours : 1 heure 30
TD : 0 heure

1.1 De la programmation classique vers la programmation orientée objet

La programmation classique telle que étudiée au travers des langages C, Pascal… définie un programme
comme étant un ensemble de données sur lesquelles agissent des procédures et des fonctions.
Les données constituent la partie passive du programme. Les procédures et les fonctions constituent la
partie active.
Programmer dans ce cas revenait à :
- définir un certain nombre de variables (structures, tableaux…)
- écrire des procédures pour les manipuler sans associer explicitement les unes aux autres.
Exécuter un programme se réduit alors à appeler ces procédures dans un ordre décrit par le séquençage
des instructions et en leur fournissant les données nécessaires à l’accomplissement de leurs tâches.

Mlle I.Sghaier - 4
 POO – CONCEPTS DE BASE DE LA POO

Dans cette approche données et procédure sont traitées indépendamment les unes des autres sans tenir
compte des relations étroites qui les unissent.
Les questions qu’on peut poser dans ce cas :
1. Cette séparation (données, procédures) est elle utile ?
2. Pourquoi privilégier les procédures sur les données (Que veut-on faire ?) ?
3. Pourquoi ne pas considérer que les programmes sont avant tout des ensembles objets
informatiques caractérisé par les opérations qu’ils connaissent ?
Les langages objets sont nés pour répondre à ces questions. Ils sont fondés sur la connaissance d’une
seule catégorie d’entités informatiques : les objets.
Un objet incorpore des aspects statiques et dynamiques au sein d’une même notion.
Avec les objets ce sont les données qui deviennent prépondérantes. On répond tout d’abord à la question
« De quoi parle-t-on ? »

Données Données

Méthodes Méthodes

Objet 1 Objet 2

Un programme est constitué d’un ensemble d’objets chacun disposant d’une partie procédures et d’une
partie données. Les objets interagissent par envoie de messages.

1.2 Définitions
1.2.1 POO

La POO est une méthode d’implémentation dans laquelle les programmes sont organisés sous formes de
collections coopératives d’objets, dont chacun représente une instance d’une classe quelconque et dont
toutes les classes sont membres d’une hiérarchie de classes unis à travers des relations d’héritage.

1.2.2 Algorithmique Objet

Dans l’approche orienté objet un algorithme sera essentiellement vu comme un ensemble d’objets
auxquels l’utilisateur envoie des messages et qui s’en envoient pendent le fonctionnement.
Ces objets seront toujours pour l’utilisateur des boites noires et qui contiendront des variables locales,
inconnues de l’environnement, et qui ne s’y intéressera d’ailleurs pas. Le seul moyen d’accéder à ces objets
sera l’envoie des messages qu’ils sont capables de comprendre.
Rq : La spécification d’un système dans l’approche OO va s’axer principalement sur la détermination des
objets à manipuler. Une fois cette étape réalisé le concepteur n’aura plus qu’à réaliser les fonctions de haut
niveau qui s’appuient sur les objets et les familles d’objets définis.

Mlle I.Sghaier - 5
 POO – CONCEPTS DE BASE DE LA POO

1.2.3 Objet et classe

 Un objet est une entité logicielle :

- Ayant une identité
- Capable de sauvegarder un état c'est-à-dire un ensemble d’information dans des variables
internes.
- Répondant à des messages précis en déclenchant des activations internes appropriés qui
changent l’état de l’objet. Ces opération sont appelées méthodes. Ce sont des fonctions
liées à des objets et qui précisent le comportement de ces objets.

1.2.4 Attributs
Les attributs d’un objet sont l’ensemble des informations se présentant sous forme de variable et
permettant de représenter l’état de l’objet.

1.2.5 Message
Un message est une demande d’activation d’une méthode envoyé à un objet.

1.2.6 Méthodes
Une méthode est une fonction ou procédure liée à un objet qui est déclenchée à la réception d’un message
particulier : la méthode déclenchée correspond strictement au message reçu. La liste des méthodes définies
au sein d’un objet constitue l’interface de l’objet pour l’utilisateur : ce sont les messages que l’objet peut
comprendre si on les lui envoie et dont la réception déclenche les méthodes correspondantes.

1.2.7 Signature
La signature d’une méthode représente la précision de son nom, du type de ses arguments et du type de
donnée retournée.

1.3 Concept de base de la POO

La POO se base sur les notions clés suivantes :
- Encapsulation
- Abstraction
- Classe et objets
- Héritage
- Polymorphisme

1.3.1 Encapsulation

Mlle I.Sghaier - 6
 POO – CONCEPTS DE BASE DE LA POO

L’encapsulation est le faite qu’un objet renferme ses propres attributs et ses méthodes. Les détails de
l’implémentation d’un objet sont masqués aux autres objets du système à objets. On dit qu’il ya
encapsulation de données et du comportement des objets.
On précise trois modes d’accès aux attributs d’un objet.
- Le mode public avec lequel les attributs seront accessibles directement par l’objet lui même
ou par d’autres objets. Il s’agit du niveau le plus bas de protection.
- Le mode private avec lequel les attributs de l’objet seront inaccessibles à partir d’autres
objets : seules les méthodes de l’objet pourront y accéder. Il s’agit du niveau le plus fort de
protection.
- Le mode protected : cette technique de protection est étroitement associée à la notion
d’héritage (suite du cours).

1.3.2 Abstraction
C’est le faite de se concentrer sur les caractéristiques importantes d’un objet selon le point de vue de
l’observateur.
Exemple : Voiture
L’abstraction est un principe qui consiste à ignorer certains aspects d’un sujets qui ne sont pas importants
pour le problème dans le but de se concentrer sur ceux qui le sont.

1.3.3 Classes, objets, instances

 Une classe est un ensemble d’objets qui ont en commun :
- les mêmes méthodes
- les mêmes types d’attributs

Classe = attributs + méthodes + instanciations

 Une instance d’une classe est un objet particulier d’une classe qui peut activer les méthodes de la classe
et qui a des valeurs particulières de ses attributs.
 On définit l’objet comme l’instance d’une classe. La classe représente pour l’objet ce que représente le
type pour la variable. Un objet est caractérisé par :
 Son identité (OID) : valeur unique et invariante qui caractérise l’objet
 Son comportement : qui est défini à travers les méthodes applicables à cet objet et qui
caractérisent sa façon d’agir et de réagir dans son environnement.
 Son état : qui constitue l’ensemble des valeurs des attributs de cet objet.
 Une classe est un type abstrait qui encapsulent données et traitement. C’est une sorte de moule qui
permet ensuite de créer autant d’instances qu’on veut. Ces instances seront des objets de la classe
auxquelles on pourra effectivement envoyer des messages qui activeront les méthodes
correspondantes.

Mlle I.Sghaier - 7
 POO – CONCEPTS DE BASE DE LA POO

Classe Etudiant
Attributs : Objet 1 : Etudiant1
Nom : char[] nom
Prenom : char[] prenom Nom : Aoun
Age : int a Prenom : Abdelkarim
Age : 20
Méthodes :
Lecture-etudiant() 3 instances de
Objet 2 : Etudiant2 la classe
Ecriture-etudiant()
Nom : Garbi Etudiant
Calcul-age()
Prenom : Wissem
Age : 19

Objet 3 : Etudiant3
Nom : Jlassi
Prenom : Imene
Age : 18

1.3.4 Héritage
La notion d’héritage est une relation entre différentes classes permettant de définir une nouvelle classe en
se basant sur les classes existantes. On parle d’héritage simple lorsqu’uen classe fille ne possède qu’une
classe mère.
On parle d’héritage multiple lorsqu’une classe fille possède plusieurs classes filles.

Classe A Classe mère

Classe B Classe fille

Héritage simple

Classe A Classe B

Classe C

Héritage Multiple
1.3.5 Polymorphisme
Le terme polymorphisme issu du grec signifie la faculté de prendre plusieurs formes.

Mlle I.Sghaier - 8
 POO – CONCEPTS DE BASE DE LA POO

Une entité est polymorphe si à l’exécution elle peut se référer à des instances de classe différentes.
Exemples :

Secrétaire Employé Ingénieur

Calcul-salaire() Calcul-salaire() Calcul-salaire()

Personne Poisson

nage() nage()

Le polymorphisme est un mécanisme qui permet à une sous classe de redéfinir une méthode dont elle a
hérité tout en gardant la même signature de la méthode.

Mlle I.Sghaier - 9
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

CHAPITRE 2 :

LES CONCEPTS ORIENTES OBJETS EN JAVA

Objectifs spécifiques
1. Introduire le concept de classe et sa notation (1/2 heure)
2. Maîtriser la définition des attributs et méthodes d’une classe (1 heure 30)
3. Maîtriser l’instanciation des objets et l’accès aux membres d’un objet (2 heures 30)
4. Comprendre le concept des classes internes (1 heure 30)
5. Maîtriser l’atout d’organisation « package » (1 heure 30)

Eléments de contenu
I. Notion de classe
II. Attributs et méthodes
III. Objets et Instanciation
IV. Membres statiques et mots clés final, this et null
V. Les classes internes
VI. Les packages

Volume Horaire :
Cours : 7 heures 30
Travaux Pratiques : 15 heures (5 TPs)

2.1 Notion de Classe

2.1.1 Concept
 Une classe est un support d’encapsulation : c'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. Entre classe et objet il y a, en quelque
sorte, le même rapport qu'entre type et variable.
 En Java : tout appartient à une classe sauf les variables de types primitifs (int, float…).
 Pour accéder à une classe il faut en déclarer une instance de cette classe (ou un objet).
 Une classe comporte sa déclaration, des variables et la définition de ses méthodes.
 Une classe se compose de deux parties : un en-tête et un 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.

Mlle I.SGHAIER 10
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

 Les méthodes et les données sont pourvues d'attributs de visibilité qui gère leur accessibilité par les
composants hors de la classe.

2.1.2 Syntaxe
modificateur nom_classe [extends classe_mere]
[implements interface]
{
// Insérer ici les champs et les méthodes
}
Les modificateurs de classe (ClassModifiers) sont :

Modificateur Rôle
public La classe est accessible partout

private la classe n'est accessible qu'à partir du fichier où elle est définie

final La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite. Les
classes déclarées final ne peuvent donc pas avoir de classes filles.

abstract 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 une classe qui
hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être
abstraite. Ce modificateur sera manipulé dans un prochain chapitre.

Les modificateurs abstract et final ainsi que public et private sont mutuellement exclusifs (c-à-d on ne
peut ni avoir public suivi de private ni abstract suivi de final).
Le mot clé extends permet de spécifier une superclasse éventuelle : ce mot clé permet de préciser la classe
mère dans une relation d'héritage (qui sera manipulé dans un prochain chapitre).
Le mot clé implements permet de spécifier une ou des interfaces (qui seront manipulées dans un
prochain chapitre) que la classe implémente. Cela permet de récupérer quelques avantages de l'héritage
multiple.
L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre d'abord la
méthode A puis la méthode B, B peut être appelée sans problème dans A.
Remarque :
Par convention, en Java les noms de classes commencent par une lettre majuscule, si elle est composé de
plusieurs mots, ces mots doivent être liés par « _ » et commencent par une lettre majuscule.

Mlle I.SGHAIER 11
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

2.2 Attributs et Méthodes

2.2.1 Les Attributs
Les données d'une classe sont contenues dans les propriétés ou attributs. Les attributs sont les données
d’une classe, ils sont tous visibles à l’intérieur de la classe.
Syntaxe générale:
[< modificateur de visibilité>] <type> <nom_attribut> [=<expression>] ;
Exemple
class Rectangle
{private int longueur ;
private int largeur ;
public Point Centre ;
}

Remarques
- Les modificateurs de visibilité sont : « public », « private » et « protected ».
- Dans la syntaxe, « expression » permet d’affecter des valeurs par défaut pour les attributs.
Ils peuvent être des variables d'instances, des variables de classes ou des constantes.

2.2.1.1 Les variables d'instances

Une variable d'instance nécessite simplement une déclaration de la variable dans le corps de la classe.
Exemple :
public class MaClasse {
public int valeur1 ;
int valeur2 ;
protected int valeur3 ;
private int valeur4 ;
}
Chaque instance de la classe a accès à sa propre occurrence de la variable.
2.2.1.2 Les variables de classes (static)
Les variables de classes sont définies avec le mot clé static
Exemple :
public class MaClasse {
static int compteur ;
}
Chaque instance de la classe partage la même variable.
2.2.1.3 Les constantes

Mlle I.SGHAIER 12
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Les constantes sont définies avec le mot clé final : leur valeur ne peut pas être modifiée.
Exemple :
public class MaClasse {
final double pi=3.14 ;
}

2.2.2 Les méthodes

Les méthodes sont des fonctions qui implémentent les traitements de la classe.
2.2.2.1 La syntaxe de la déclaration
La syntaxe de la déclaration d'une méthode est :
modificateurs type_retourné nom_méthode ( arg1, ... ) {... }
// Définition des variables locales et du bloc d'instructions
// Les instructions
}
Le type retourné peut être élémentaire ou correspondre à un objet. Si la méthode ne retourne rien, alors
on utilise void.
Le type et le nombre d'arguments déclarés doivent correspondre au type et au nombre d'arguments
transmis. Il n'est pas possible d'indiquer des valeurs par défaut dans les paramètres. Les arguments sont
passés par valeur : la méthode fait une copie de la variable qui lui est locale. Lorsqu'un objet est transmis
comme argument à une méthode, cette dernière reçoit une référence qui désigne son emplacement
mémoire d'origine et qui est une copie de la variable. Il est possible de modifier l'objet grâce à ces
méthodes mais il n'est pas possible de remplacer la référence contenue dans la variable passée en
paramètre : ce changement n'aura lieu que localement à la méthode.
Une méthode représente l’équivalent d’une procédure ou fonction dans les langages classiques de
programmation.
Exemple
class Rectangle {
private int longueur ;
int largeur ;
public int calcul_surface ( ) {
return (longueur*largeur) ;
}
public void initialise (int x, int y) {
longueur =x ; largeur = y ;
}
}

Mlle I.SGHAIER 13
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

2.2.2.2 Remarques
- Toutes les méthodes sauf les «constructeurs » doivent avoir un type de retour.
- Les méthodes qui ne renvoient rien, utilisent « void » comme type de retour.
- Le code de la méthode est implémenté à la suite de l’accolade ouvrante « { ».
- Une méthode peut ne pas avoir besoin d’arguments, ni de variables à déclarer.
- Les méthodes agissent sur les attributs définis à l’intérieur de la classe.
- Sans modificateur, la méthode peut être appelée par toutes autres méthodes des classes du
package auquel appartient la classe.
- La valeur de retour de la méthode doit être transmise par l'instruction return. Elle indique la
valeur que prend la méthode et termine celle ci : toutes les instructions qui suivent return sont
donc ignorées.
Exemple :
int add(int a, int b) {
return a + b;
}
Il est possible d'inclure une instruction return dans une méthode de type void : cela permet de quitter la
méthode.
La méthode main() de la classe principale d'une application doit être déclarée de la façon suivante:
Déclaration d'une méthode main () :
public static void main (String args[]) { ... }
Si la méthode retourne un tableau alors les [] peuvent être précisés après le type de retour ou après la liste
des paramètres :
Exemple :
int[] valeurs() { … }
int valeurs()[] { … }

2.2.3 La transmission de paramètres

Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui même qui est passé mais une référence sur
l'objet. La référence est bien transmise par valeur et ne peut pas être modifiée mais l'objet peut être
modifié via un message (appel d'une méthode).
Pour transmettre des arguments par référence à une méthode, il faut les encapsuler dans un objet qui
prévoit les méthodes nécessaires pour les mises à jour.
Si un objet o transmet sa variable d'instance v en paramètre à une méthode m, deux situations sont
possibles :
 si v est une variable primitive alors elle est passée par valeur : il est impossible de la modifier dans
m pour que v en retour contienne cette nouvelle valeur.

Mlle I.SGHAIER 14
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

 si v est un objet alors m pourra modifier l'objet en utilisant une méthode de l'objet passé en
paramètre.

2.2.4 L'émission de messages

Un message est émis lorsqu'on demande à un objet d'exécuter l'une de ses méthodes.
La syntaxe d'appel d'une méthode est : nom_objet.nom_méthode(parametre, … ) ;
Si la méthode appelée ne contient aucun paramètre, il faut laisser les parenthèses vides.

2.2.5 Constructeurs
La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode particulière
appelée constructeur pour que les variables aient une valeur de départ. Elle n'est systématiquement
invoquée que lors de la création d'un objet.
Le constructeur suit la définition des autres méthodes excepté que son nom doit obligatoirement
correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y avoir
d'instruction return dans un constructeur. On peut surcharger un constructeur.
La définition d'un constructeur est facultative. Si elle n'est pas définie, la machine virtuelle appelle un
constructeur par défaut vide créé automatiquement. Dès qu'un constructeur est explicitement défini, Java
considère que le programmeur prenne en charge la création des constructeurs et que le mécanisme par
défaut, qui correspond à un constructeur sans paramètres, est supprimé. Si on souhaite maintenir ce
mécanisme, il faut définir explicitement un constructeur sans paramètres.
Il existe plusieurs manières de définir un constructeur :
● Le constructeur simple : ce type de constructeur ne nécessite pas de définition explicite: son
existence découle automatiquement de la définition de la classe.
Exemple :
public MaClasse() {}

● Le constructeur avec initialisation fixe : il permet de créer un constructeur par défaut

Exemple :
public MaClasse() {
nombre = 5;
}

● Le constructeur avec initialisation des variables : pour spécifier les valeurs de données à
initialiser on peut les passer en paramètres au constructeur
Exemple :
public MaClasse(int valeur) {
nombre = valeur;

Mlle I.SGHAIER 15
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Exemple
class Rectangle
{private int longueur ;
private int largeur ;
Rectangle () {longueur =10 ; largeur = 5 ;} // C’est un constructeur sans paramètres
Rectangle (int x, int y) {longueur =x ; largeur = y ;} // constructeur avec 2 paramètres
Rectangle (int x) {longueur =2*x ; largeur = x ;} // constructeur avec 1 paramètre
public int calcul_surface ( ) {return (longueur*largeur) ;}
}

2.2.6 Les destructeurs

Un destructeur permet d'exécuter du code lors de la libération de la place mémoire occupée par l'objet. En
java, les destructeurs appelés finaliseurs (finalizers), sont automatiquement appelés par le garbage collector.
Pour créer un finaliseur, il faut redéfinir la méthode finalize() héritée de la classe Object.

2.2.7 Les accesseurs

L'encapsulation permet de sécuriser l'accès aux données d'une classe. Ainsi, les données déclarées private à
l'intérieur d'une classe ne peuvent être accédées et modifiées que par des méthodes définies dans la même
classe. Si une autre classe veut accéder aux données de la classe, l'opération n'est possible que par
l'intermédiaire d'une méthode de la classe prévue à cet effet. Ces appels de méthodes sont appelés «
échanges de message ».
Un accesseur est une méthode publique qui donne l'accès à une variable d'instance privée.
Pour une variable d'instance, il peut ne pas y avoir d'accesseur, un seul accesseur en lecture ou un
accesseur en lecture et un en écriture. Par convention, les accesseurs en lecture commencent par get et les
accesseurs en écriture commencent par set.
Exemple :
private int valeur = 13;
public int getValeur(){
return(valeur);
}
public void setValeur(int val) {
valeur = val;
}

2.2.8 L'enchaînement de références à des variables et à des méthodes

Mlle I.SGHAIER 16
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Exemple :
System.out.Println("bonjour");
Deux classes sont impliqués dans l'instruction : System et PrintStream. La classe System possède une
variable nommée out qui est un objet de type PrintStream.Println() est une méthode de la classe
PrintStream. L'instruction signifie : « utilise la méthode Println() de la variable out de la classe System ».

2.3 Objets et Instanciation

2.3.1 Objet en Java
L’objet est l’unité de base de la conception orientée objet d’un système informatique. Il représente des
entités réelles (personne, animal…) ou conceptuelles (cercle, point, graphique…).
Les objets contiennent des attributs et des méthodes. Les attributs sont des variables ou des objets
nécessaires au fonctionnement de l'objet. En java, une application est un objet. La classe est la description
d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même,
seul les données sont différentes à chaque objet.
Un objet est caractérisé par :
- Un ensemble de données (attributs) et d’actions (méthodes) formant un tout indépendant.
- Les attributs portent des valeurs attachées à l’objet. L’ensemble de ces valeurs à un instant
donné constitue l’état de l’objet à cet instant,
- Les méthodes permettent de faire “vivre” l’objet (en lui faisant effectuer des actions et peut-être
changer son état). Elles définissant son comportement et ses réactions aux stimulations externes
et implémentent les algorithmes invocables sur cet objet,
- Une identité qui permet de le distinguer des autres objets, de manière unique.
- L’objet est “l’instanciation d’une classe”
Exemple : un bouton dans une interface graphique
- Attributs : une image, un label, une couleur de fond, une police de caractères.
- Méthodes : se dessiner, réagir quand on clique dessus.
2.3.2 Instanciation
La création d’un objet à partir d’une classe est appelée instanciation. Cet objet est une instance de sa
classe.
Une instanciation se décompose en trois phases
1. Création et initialisation des attributs en mémoire, à l’image d’une structure.
2. Appel des méthodes particulières : les constructeurs qui sont définies dans la classe
3. Renvoi d’une référence sur l’objet (son identité) maintenant créé et initialisé.

Mlle I.SGHAIER 17
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Exemple : on définit une classe Cercle, contenant entre autres un attribut rayon et un attribut
epaisseur_trait. Chaque cercle instancié de cette classe possédera son propre rayon et sa propre épaisseur
du trait.
Il est nécessaire de définir la déclaration d'une variable ayant le type de l'objet désiré. La déclaration est de
la forme classe nom_variable.
Exemple :
MaClasse m;
L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable.
Exemple :
m = new MaClasse();

Il est possible de tout réunir en une seule déclaration.

Exemple :
MaClasse m = new MaClasse();
Chaque instance d'une classe nécessite sa propre variable. Plusieurs variables peuvent désigner un même
objet.
En Java, tous les objets sont instanciés par allocation dynamique. Dans l'exemple, la variable m contient
une référence sur l'objet instancié (contient l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est
pas possible de manipuler ou d’effectuer des opérations directement sur cette adresse comme en C).
Si m2 désigne un objet de type MaClasse, l'instruction m2 = m ne définit pas un nouvel objet mais m et
m2 désignent tous les deux le même objet.
L'opérateur new est un opérateur de haute priorité qui permet d'instancier des objets et d'appeler une
méthode particulière de cet objet : le constructeur. Il fait appel à la machine virtuelle pour obtenir
l'espace mémoire nécessaire à la représentation de l'objet puis appelle le constructeur pour initialiser l'objet
dans l'emplacement obtenu. Il renvoie une valeur qui référence l'objet instancié.
Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire, il lève l'exception OutOfMemoryError.
Remarque:
Un objet String est automatiquement créé lors de l'utilisation d'une constante chaîne de caractères sauf si
celle-ci est déjà utilisée dans la classe. Ceci permet une simplification dans l'écriture des programmes.
Exemple :
String chaine = "bonjour" et String chaine = new String("bonjour") sont équivalents.
Pour instancier un objet on passe par les 2 étapes suivantes :
- Déclarer une variable de la classe que l’on désire instancier. Cette variable est une référence sur
l’objet que l’on va créer. Java y stockera l’adresse de l’objet.
Exemple : Rectangle r 1; Rectangle r2 ;….
- Allouer la mémoire nécessaire à l’objet et l’initialiser. cette opération se fait par l’intermédiaire de
l’opérateur new auquel on passe l’appel au constructeur de la classe désirée.

Mlle I.SGHAIER 18
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Exemple: r1 = new Rectangle (10, 4); r2 = new Rectangle ();

Remarque : on peut faire les deux étapes en même temps :
Rectangle r1= new Rectangle (10, 4);
L’objet est détruit lorsque il n’ y a plus des références pour cet objet (sortie d’un bloc de visibilité, etc....).
Remarques
La création des objets se fait généralement dans les classes qui utilisent la classe à instancier et plus
particulièrement dans la méthode qui constitue le point d’entrée « main ». On va distinguer 2 cas :
cas1 : la classe à instancier ne possède pas des constructeurs
Exemple
class Rectangle
{private int longueur ;
private int largeur ;
public int calcul_surface ( )
{return (longueur*largeur) ;}
public void initialise (int x, int y) {
longueur =x ; largeur = y ;}
public void initialise (int x) {
longueur =2*x ; largeur = x ;}
}
public class Test_Rect
{public static void main (String [] argv)
{Rectangle r1, r3;
Rectangle r2 = new Rectangle ();
r1 = new Rectangle ();
r3 = new rectangle (5);
/*erreur car la classe ne définit pas des
constructeurs*/
………
}
}
cas2 : la classe à instancier possède au moins un constructeur
Exemple
class Rectangle
{private int longueur ;
private int largeur ;
Rectangle (int x, int y) {longueur =x ; largeur = y ;}
// constructeur avec 2 paramètres

Mlle I.SGHAIER 19
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Rectangle (int x) {longueur =2*x ; largeur = x ;}

// constructeur avec 1 paramètre
public int calcul_surface ( ) {return (longueur*largeur) ;}
}
Rectangle r1 = new Rectangle (10,4)
// juste car on a un constructeur avec 2 paramètres.
Rectangle r1 = new Rectangle (10)
// juste car on a un constructeur avec 1 paramètre.
Rectangle r1 = new Rectangle ()
// faux car on a pas un constructeur sans paramètres. Le constructeur
par défaut n’est plus valable car la classe possède au moins un
constructeur.

2.3.3 La durée de vie d'un objet

Les objets ne sont pas des éléments statiques et leur durée de vie ne correspond pas forcément à la durée
d'exécution du programme.
La durée de vie d'un objet passe par trois étapes :
 la déclaration de l'objet et l'instanciation grâce à l'opérateur new
Exemple :
nom_classe nom_objet = new nom_classe( ... );
 l'utilisation de l'objet en appelant ces méthodes
 la suppression de l'objet : elle est automatique en java grâce à la machine virtuelle. La
restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire
(garbage collector). Il n'existe pas d'instruction delete comme en C++.

2.3.4 La création d'objets identiques

Exemple :
MaClasse m1 = new MaClasse();
MaClasse m2 = m1;
m1 et m2 contiennent la même référence et pointent donc tous les deux sur le même objet : les
modifications faites à partir d'une des variables modifient l'objet.
Pour créer une copie d'un objet, il faut utiliser la méthode clone() : cette méthode permet de créer un
deuxième objet indépendant mais identique à l'original. Cette méthode est héritée de la classe Object qui
est la classe mère de toutes les classes en Java.
Exemple :
MaClasse m1 = new MaClasse();
MaClasse m2 = m1.clone();

Mlle I.SGHAIER 20
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

m1 et m2 ne contiennent plus la même référence et pointent donc sur des objets différents.

2.3.5 Les références et la comparaison d'objets

Les variables déclarés de type objet ne contiennent pas un objet mais une référence vers cet objet. Lorsque
l'on écrive c1 = c2 (c1 et c2 sont des objets), on copie la référence de l'objet c2 dans c1 : c1 et c2 réfèrent
au même objet (ils pointent sur le même objet). L'opérateur == compare ces références. Deux objets avec
des propriétés identiques sont deux objets distincts :
Exemple :
Rectangle r1 = new Rectangle(100,50);
Rectangle r2 = new Rectangle(100,50);
if (r1 == r1) { ... } // vrai
if (r1 == r2) { ... } // faux
Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'un méthode à cette effet :
la méthode equals héritée de Object.
Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la classe
Object dont toutes les classes héritent.
Exemple :
(obj1.getClass().equals(obj2.getClass())

2.3.6 Utilisation des objets

L’utilisation des objets se manifeste selon 2 axes : l’accès aux attributs et l’accès aux méthodes.
2.3.6.1 L’accès aux attributs
- Pour accéder aux attributs de l’intérieur de la classe, il suffit d’indiquer le nom de l’attribut que
l’on veut y accéder.
- Pour accéder de l’extérieur de la classe, on utilise la syntaxe suivante :
<nom_méthode>.<nom_attribut>

2.3.6.2 L’accès aux méthodes

- A l’intérieur d’une classe, les méthodes de cette classe seront appelées en indiquant le nom et la
liste des paramètres effectifs de la méthode.
- A l’extérieur de la classe, l’invocation d’une méthode se fait comme suit :
<nom_classe>.<nom_méthode> ( [<liste des arguments effectifs>] ) ;
- La liste des arguments effectifs doit concorder en nombre et en type avec la liste des arguments
formels.
Exemple
Dans la méthode « main » de la classe Test_Rect, on peut appeler les méthodes ainsi :

Mlle I.SGHAIER 21
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Rectangle r = new Rectangle (10,5) ;

r.affiche() ; // Appel de la méthode affiche
int s = r.calcul_surface() ; //Appel de la méthode calcul_surface
r.setlong(20) ; //Appel de la méthode setlong pour modifier la longueur

2.4 Membres statiques et Autres mots clés (final, this, null)

2.4.1 Les attributs statiques
Les attributs statiques sont des attributs marqués par le mot clé « static », ils désignent les attributs
communs entre tous les objets.
On accède à un attribut statique via :
- Une instance quelconque de la classe.
- Le nom de la classe directement.

Si on souhaite sauvegarder le nombre des objets crées et attribuer à chaque objet son numéro d’ordre.
Pour satisfaire à cet objectif, on a certainement besoin d’un attribut de type statique qui est commun à
tous les objets et qui sauvegarde le nombre d’objets déjà crées.

On va reformuler l’exemple précèdent, en ajoutant un attribut statique appelé count qui va indiquer le
nombre d’objets crées et un attribut qui s’appelle num qui indique le numéro d’ordre d’un objet, cet
attribut n’est pas statique car sa valeur est propre à chaque objet.

Exemple :

class Rectangle
{static int count =0;
private int longueur, larg;
private int num;
Rectangle (int x, int y) {
Count++ ; num = count ; longueur = x ; largeur = y ;}
…….Les autres méthodes
}

class Test_Rec
{
public static void main (String [] args)
{System.out.println (“Nombre des objets = ” + Rectangle.count) ; // affiche 0
Rectangle r = new Rectangle (10,5);
System.out.println (“Nombre des objets = ” + Rectangle.count) ; // affiche 1
System.out.println (“Numéro de l’objet crée = ” + r.num) ; //affiche 1
Rectangle r3;
r3= new Rectangle (14);

Mlle I.SGHAIER 22
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

System.out.println (“Nombre des objets = ” + Rectangle.count) ; //affiche 2

System.out.println (“Numero de l’objet crée = ” + r3.num) ; //affiche 2
Rectangle r2 = new Rectangle();
System.out.println (“Nombre des objets = ” + Rectangle.count) ; //affiche 3
System.out.println (“Numero de l’objet crée = ” + r2.num) ; //affiche 3
}
}

2.4.2 Les méthodes statiques

S’appellent aussi méthodes de classe, elles désignent les méthodes dont les actions concernent la classe
entière et non pas un objet particulier.
De même, l’accès à ces méthodes ne nécessite pas la création d’un objet de la classe, car on peut appeler
directement la méthode à travers le nom de la classe. On peut utiliser aussi ces méthodes statiques pour
manipuler des données statiques

Exemple

On va définir une classe Math qui peut contenir des fonctions mathématiques. De préférence, on déclare
ces méthodes comme étant statiques pour pouvoir les utiliser sans instancier des objets de cette classe.

Public class Math {

static double PI = 3.14 ; //c’est un attribut statique

static double getPI () {Return (PI) ;} // La méthode statique manipule des attributs
statiques
static double diametre (double r) {return (PI*2*r)} // c’est une méthode statique
static double puissance (double x) {return (x*x);} // c’est une méthode statique
}
class Test_Math {
public static void main (String [] args) {
double i= Math.power (6);
System.out.println (“I=” + i);
Math m = new Math ();
double d = m.rayon (5.1);
System.out.println (“Le diametre = “ + d);
}
}
On remarque que l’accès à une méthode se fait de deux manières soit à travers le nom de la classe (le
premier appel de la méthode power), soit à travers un objet de la classe (Le deuxième appel de la
méthode statique rayon).

Mlle I.SGHAIER 23
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

2.4.3 Le mot clé « final »

Le mot clé final s'applique aux variables, aux méthodes et aux classes.
Une variable qualifiée de final signifie que la variable est constante. Une variable déclarée final ne peut
plus voir sa valeur modifiée. On ne peut déclarer de variables final locales à une méthode. Les constantes
sont qualifiées de final et static.
Exemple :
public static final float PI = 3.1416f;
Une méthode final ne peut pas être redéfinie dans une sous classe. Une méthode possédant le
modificateur final pourra être optimisée par le compilateur car il est garanti qu'elle ne sera pas sous classée.
Lorsque le modificateur final est ajouté à une classe, il est interdit de créer une classe qui en hérite.
Il existe 2 types d’utilisations des attributs finaux : ou bien on initialise la valeur de la variable dés la
déclaration, ou bien on initialise plus tard cette variable et son contenu ne sera jamais modifiée.
Remarque : Le mot clé final peut aussi être utilisé avec les méthodes et les classes. Cette utilisation va être
détaillée dans les autres chapitres.
2.4.4 Le mot clé « this »
Cette variable sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. this est un
objet qui est égale à l'instance de l'objet dans lequel il est utilisé.
La référence « this » peut être utile :
- Lorsqu’une variable locale (ou un paramètre) cache, en portant le même nom, un attribut de la
classe.
- Pour appeler un constructeur depuis un autre constructeur.
Exemple
class Rectangle {
private int longueur, largeur ;
private String couleur ;
Rectangle (int lo, int largeur)
{longueur = lo ;
this.largeur = largeur ;}
//1er cas : même nom entre le paramètre et l’attribut
Rectangle (int lo, int lar, String coul) {
this (lo, lar);
// 2 ème cas : appel d’un constructeur à partir d’un autre
couleur = coul;}
}

This est aussi utilisé quand l'objet doit appeler une méthode en se passant lui même en paramètre de
l'appel.

Mlle I.SGHAIER 24
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

2.4.5 Le mot clé « null »

L'objet null est utilisable partout. Il n'appartient pas à une classe mais il peut être utilisé à la place d'un
objet de n'importe quelle classe ou comme paramètre. Il permet de représenter la référence qui ne
référence rien. C’est aussi la valeur par défaut d’initialisation des attributs représentant des références.
null ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel de méthodes et aucune classe ne
puisse en hériter.
Le fait d'initialiser une variable référent un objet à null permet au ramasseur de miettes (garbage collector)
de libérer la mémoire allouée à l'objet.
Exemple
class Test_Rec {
public static void main (String [] args) {
Rectangle r;
if (r==null)
r= new Rectangle (10,12);
r.affiche();
}
}

2.5 Les classes internes

Une classe interne (ou imbriquée) est une classe définie à l’intérieur d’une autre classe au même niveau
qu’une méthode ou attribut.
- Les classes internes sont visibles uniquement par les méthodes de la classe dont laquelle sont
définies.
- Elles ont accès à tous les éléments de la classe qui les englobe (même privé).
- On ne peut pas accéder directement aux attributs et aux méthodes de la classe interne. Toutefois,
on peut les appeler indirectement à travers la classe externe qui l’englobe.
Exemple
Supposons qu’on veut représenter à l’intérieur de la classe Rectangle une classe Point qui permet
de représenter le centre de rectangle. Cette classe Point sera interne à la classe Rectangle.
Class Rectangle {
private int longueur;
private int larg;
Rectangle(int l, int a)
{longueur= l;
larg= a;}
class Point {

Mlle I.SGHAIER 25
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

int x, y;
Point ( int x1, int y1)
{x=x1; y=y1;}
void affichep ()
{System.out.println ("Le centre se trouve dans " + x + " " + y);
}
}
Point p = new Point (10,5);
void affiche () {
System.out.println ("Longueur=" + longueur + " Largeur =" + larg);
}
}
class test_Rec{
public static void main(String [] args){
Rectangle r = new Rectangle (4,6);
Point p = new Point(12,14); //faux car la classe Point est invisible de l’extérieur
r.p.affichep(); //on peut accéder à une méthode de la classe interne à travers l’attribut p de l’objet r.
r.affiche() ;
}
}

2.6 Les packages

En java, il existe un moyen de regrouper des classe voisines ou qui couvrent un même domaine : ce sont
les packages. Un package peut être considéré comme une bibliothèque des classes : il permet de regrouper
un certain nombre des classes relativement liées. Les packages peuvent être organisés d’une manière
hiérarchique en sous-packages et ainsi de suite
Avantages
- Facilite le développement des bibliothèques et des modules autonomes.
- Les classes d’un même package travaillent conjointement sur un même domaine.
- Facilite la réutilisabilité.

Organisation
- Les classes d’un package se trouvent dans un répertoire décrit par le nom du package.
- Ainsi les classes du package Java.lang se trouvent dans un sous-répertoire java/lang accessible
par la variable d’environnement CLASSPATH.

Mlle I.SGHAIER 26
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

2.6.1 Création d’un package

Pour réaliser un package :
1. Ajouter dans chaque fichier “.java” composant le package la ligne :
package <nom_du_package>;
2. Enregistrer le fichier dans un répertoire portant le même nom que le package.
3. Ajouter le chemin de package dans la variable CLASSPATH.
La hiérarchie d'un package se retrouve dans l'arborescence du disque dur puisque chaque package est dans
un répertoire nommé du nom du package.
Remarques :
Il est préférable de laisser les fichiers source .java avec les fichiers compilés .class
D'une façon générale, l'instruction package associe toutes les classes qui sont définies dans un
fichier source à un même package.
Le mot clé package doit être la première instruction dans un fichier source et il ne doit être présent
qu'une seule fois dans le fichier source (une classe ne peut pas appartenir à plusieurs packages).
Le compilateur et la JVM utilisent la variable CLASSPATH pour localiser les emplacements des
répertoires servant de racine à une arborescence de packages. Donc, il faut ajouter les localisations
des répertoires à cette variable.
Java importe automatiquement le package « java.lang » qui contient la classe « System ».

2.6.2 L'utilisation d'un package

Pour utiliser ensuite le package ainsi créé, on l'importe dans le fichier :
import nomPackage.*;
Pour importer un package, il y a trois méthodes si le chemin de recherche est correctement renseigné :
Exemple Rôle

import nomPackage; les classes ne peuvent pas être simplement désignées par leur
nom et il faut aussi préciser le nom du package
import nomPackage.*; toutes les classes du package sont importées
import nomPackage.nomClasse; appel à une seule classe : l'avantage de cette notation est de
réduire le temps de compilation

Attention : l'astérisque n'importe pas les sous paquetages. Par exemple, il n'est pas possible d'écrire
import java.*.
Il est possible d'appeler une méthode d'un package sans inclure ce dernier dans l'application en précisant
son nom complet :
nomPackage.nomClasse.nomméthode(arg1, arg2 ... )

Mlle I.SGHAIER 27
 POO – CONCEPTS ORIENTES OBJETS EN JAVA

Il existe plusieurs types de packages : le package par défaut (identifié par le point qui représente le
répertoire courant et permet de localiser les classes qui ne sont pas associées à un package particulier), les
packages standards qui sont empaquetés dans le fichier classes.zip et les packages personnels.
Le compilateur implémente automatiquement une commande import lors de la compilation d'un
programme Java même si elle ne figure pas explicitement au début du programme :
import java.lang.*; Ce package contient entre autre les classes de base de tous les objets java dont la classe
Object.
Un package par défaut est systématiquement attribué par le compilateur aux classes qui sont définies sans
déclarer explicitement une appartenance à un package. Ce package par défaut correspond au répertoire
courant qui est le répertoire de travail.
2.6.3 Quelques packages prédéfinis
 Le package math permet d’utiliser les fonctions mathématiques ;
 Dans io tout ce qu'il faut pour manipuler les entrées, les sorties, ...
 sql contient les classes et méthodes pour interfacer vos applications avec des bases de données
(interface JDBC).

2.6.4 La collision de classes

Deux classes entrent en collision lorsqu'elles portent le même nom mais qu'elles sont définies dans des
packages différents. Dans ce cas, il faut qualifier explicitement le nom de la classe avec le nom complet du
package.
2.6.5 Les packages et l'environnement système
Les classes Java sont importées par le compilateur (au moment de la compilation) et par la machine
virtuelle (au moment de l'exécution). Les techniques de chargement des classes varient en fonction de
l'implémentation de la machine virtuelle. Dans la plupart des cas, une variable d'environnement
CLASSPATH référence tous les répertoires qui hébergent des packages susceptibles d'être importés.
Exemple sous Windows :
CLASSPATH = .;C:\Java\JDK\Lib\classes.zip; C:\rea_java\package
L'importation des packages ne fonctionne que si le chemin de recherche spécifié dans une variable
particulière pointe sur les packages, sinon le nom du package devra refléter la structure du répertoire où il
se trouve. Pour déterminer l'endroit où se trouvent les fichiers .class à importer, le compilateur utilise une
variable d'environnement dénommée CLASSPATH. Le compilateur peut lire les fichiers .class comme des
fichiers indépendants ou comme des fichiers ZIP dans lesquels les classes sont réunies et compressées.

Mlle I.SGHAIER 28
 POO – ENCAPSULATION ET SURCHARGE

CHAPITRE 3 :

Encapsulation et surcharge

Objectifs spécifiques
1. Introduire la notion d’encapsulation et ses intérêts pratiques
2. Comprendre les droits d’accès aux membres et aux classes
3. Maîtriser le concept de surcharge des méthodes

Eléments de contenu
I. L’encapsulation
II. Modificateurs de visibilité et accès
III. Surcharge des méthodes

Volume Horaire :
Cours : 3 heures
Travaux Pratiques : 9 heures

L’encapsulation

L’encapsulation est la possibilité de ne montrer de l’objet que ce qui est nécessaire à son utilisation.
L’encapsulation permet d’offrir aux utilisateurs d’une classe la liste des méthodes et éventuellement des
attributs utilisables depuis l’extérieur. Cette liste de services exportables est appelée l’interface de la classe
et elle est composée d’un ensemble des méthodes et d’attributs dits publics (Public).
Les méthodes et attributs réservés à l’implémentation des comportements internes à l’objet sont dits
privés (Private). Leur utilisation est exclusivement réservée aux méthodes définies dans la classe
courante.
Les avantages de l’encapsulation sont :
- Simplification de l’utilisation des objets,
- Meilleure robustesse du programme,
- Simplification de la maintenance globale de l’application

Modificateurs de visibilité et Accès

Modificateurs de visibilité

Mlle I.SGHAIER 29
 POO – ENCAPSULATION ET SURCHARGE

Les attributs et les méthodes sont précédés lors de la déclaration par l’un des modificateurs de visibilité
suivants : « public », « private », « protected » et Néant.

- Une méthode, classe ou attribut sont déclarés comme publiques « public » s’ils doivent être
visibles à l’intérieur et à l’extérieur quelque soit leur package.
- Une méthode, classe ou attribut ne sont pas précédés par un modificateur de visibilité explicite
(Néant) ne vont être visibles qu’à l’intérieur de même package. C'est-à-dire seules les classes de
même package peuvent accéder aux attributs et méthodes de classes « amies ». Ce modificateur de
visibilité est aussi appelé « modificateur de package » ou modificateur « freindly ».
- Une méthode ou attributs définis comme étant privés « private » s’ils sont accessibles
uniquement par les méthodes de la classe en cours. Ils ne sont pas accessibles ailleurs.
- Une méthode ou attribut sont définis comme protégés « protected » s’ils ne peuvent être
accessibles qu’à travers les classes dérivées ou les classes de même package.
Tableaux récapitulatifs des droits d’accès

Modificateurs d’accès des classes et interfaces

Modificateur Signification pour une classe ou une interface

public Accès toujours possible

Néant Accès possible depuis les classes du même paquetage

Modificateurs d’accès pour les membres et les classes internes

Modificateur Signification pour les membres et les classes internes

public Accès possible partout où la classe est accessible

néant Accès possible depuis toutes les classes du même paquetage

protected Accès possible depuis toutes les classes de même paquetage ou depuis les classes dérivées

private Accès restreint à la classe où est faite la déclaration (du membre ou de la classe interne)

2- Accès aux membres privés

- Pour accéder aux attributs de l’intérieur de la classe, il suffit d’indiquer le nom de l’attribut que
l’on veut y accéder.

- Pour accéder de l’extérieur de la classe, on utilise la syntaxe suivante :

<nom_méthode>.<nom_attribut>

Mlle I.SGHAIER 30
 POO – ENCAPSULATION ET SURCHARGE

Exemple 1

 Si longueur et largeur étaient des attributs publics de Rectangle, on peut écrire le code suivant dans la
méthode « main » de la classe Test_Rect

Rectangle r = new Rectangle ();

r.longueur = 20;
r.largeur = 15;
int la = r.longueur ;

 Si longueur et largeur étaient des attributs privés « private », les instructions suivantes seront refusées
par le compilateur

r.longueur = 20; //faux

r.largeur = 15; //faux
int la = r.longueur ; //faux

 Il fallait dans le deuxième cas définir des méthodes d’accés « setlong (int) » et « setlarg (int) » qui
permettent de modifier les valeurs des attributs et les méthodes d’accès « getlong ()» et « getlarg ()» pour
retourner les valeurs de longueur et de largeur d’un objet Rectangle. Dans ce cas, les instructions seront les
suivantes :

r.setlong(20); //juste
r.setlarg(15); //juste
int la = r.getlong() ; //juste

Exemple 2
public class Rectangle
{
private int longueur;
private int larg;

Rectangle (int l, int a) //Le premier constructeur

{longueur= l;
larg= a;}
Rectangle() // Le deuxième constructeur
{longueur= 20;
larg= 10;}
Rectangle (int x) //Le troisième constructeur
{longueur= 2*x;
larg= x;}

Mlle I.SGHAIER 31
 POO – ENCAPSULATION ET SURCHARGE

int getlong () //pour retourner la valeur de longueur

{return (longueur);
}
int getlarg () //Pour retourner la largeur
{return (larg);
}
void setlong (int l) //pour modifier la longueur
{longueur=l;
}
void setlarg (int l) //pour modifier la largeur
{larg=l;
}
int surface() //Pour calculer la surface
{return(longueur*larg);
}
int périmètre() //pour calculer le périmètre
{
return((larg+longueur)*2);
}
void allonger(int l) //Pour allonger la longueur d’un rectangle
{
longueur+=l;
}
void affiche() //pour afficher les caractéristiques d’un rectangle
{
System.out.println("Longueur=" + longueur + " Largeur =" + larg );
}
}

Code de la classe Test_Rect

class Test_Rec
{
public static void main(String []args)
{
Rectangle r = new Rectangle(10,5);
Rectangle r3;
r3= new Rectangle (14);

Mlle I.SGHAIER 32
 POO – ENCAPSULATION ET SURCHARGE

Rectangle r2 = new Rectangle();

r.affiche();
r2.affiche();
r3.affiche() ;
r2.setlong(50);
r2.setlarg(30);
r2.affiche();
System.out.println("Rectangle1" );
System.out.println("Surface= " + r.surface());
System.out.println("Périmetre= " + r.perimetre());
r.allonger(40);
System.out.println("Aprés allongement");
r.affiche();
}
}

Surcharge des Méthodes

La surcharge est la capacité des objets d’une même hiérarchie de classes à répondre
différemment à une méthode de même nom, mais avec des paramètres différents. Par exemple,
la classe Rectangle peut avoir plusieurs méthodes Allonger () acceptant des paramètres différents
en nombre et/ou en types.

En fonction du type et de nombre de paramètres lors de l’appel, la méthode correspondante

sera choisie.

Le mécanisme de surcharge permet de réutiliser le nom d’une méthode déjà définie, pour une
autre méthode qui en différera par ses paramètres.

La méthode surchargée doit conserver la même “intention sémantique”

La surcharge peut se faire sur une méthode définie localement ou héritée.

Exemple

void allonger(int l) //Pour allonger la longueur d’un rectangle

{
longueur+=l;
}

Mlle I.SGHAIER 33
 POO – ENCAPSULATION ET SURCHARGE

void allonger(int l, int k) //Pour allonger un rectangle

{
longueur+=l;
larg+= k
}
Lors de l’appel des méthodes surchargées, le compilateur sait distinguer entre les méthodes en considérant
le nombre et les types des paramètres
Rectangle r = new Rectangle (5,10) ; //Appel de constructeur à 2 paramètres
r.allonger (10) ; // Appel de la 1ère méthode surchargée
r.allonger (10, 3) ; // Appel de la 2ème méthode surchargée

Mlle I.SGHAIER 34
 POO – ENCAPSULATION ET SURCHARGE

TD1

Exercice 1:

Voici la source de la classe Livre :

public class Livre {

// Variables
private String titre, auteur;
private int nbPages

// Constructeur
public Livre(String unAuteur, String unTitre) {
auteur = unAuteur;
titre = unTitre;
}

// Accesseur
public String getAuteur() {
return auteur;
}

// Modificateur
void setNbPages(int n) {
nbPages = nb;
}

a- Corrigez quelques petites erreurs

b- ajoutez une méthode main() pour Créer 2 livres, Faire afficher les auteurs de ces 2 livres.

Exercice 2:

Accesseurs et modificateurs

1) Modifiez la classe Livre :

Mlle I.SGHAIER 35
 POO – ENCAPSULATION ET SURCHARGE

- Ajoutez un accesseur pour la variable titre et la variable nbPages.

- Ajoutez un modificateur pour les variables auteur et titre.
- Changez le modificateur de nbPages : il ne devra changer le nombre de pages que si on lui passe
en paramètre un nombre positif, et ne rien faire sinon, en affichant un message d'erreur.

2) Dans la méthode main(),

a- indiquez le nombre de pages de chacun des 2 livres,

b- faites afficher ces nombres de pages,
c- calculez le nombre de pages total de ces 2 livres et affichez-le.

Exercice 3:

1) Dans La classe Livre, ajoutez une méthode afficheToi() qui affiche une description du livre
(auteur, titre et nombre de pages).
2) Ajoutez une méthode toString() qui renvoie une chaîne de caractères qui décrit le livre.Modifiez
la méthode afficheToi() pour utiliser toString().
Voyez ce qui est affiché maintenant par l'instruction System.out.println(livre).

3) Ajoutez 2 constructeurs pour avoir 3 constructeurs dans la classe :

- Un constructeur qui n'a pas de paramètre

- Un qui prend en paramètre l'auteur et le titre du livre,

- et l'autre qui prend en plus le nombre de pages.

Utilisez les 3 constructeurs (et éventuellement d'autres méthodes) pour créer 3 livres de 300 pages dans la
méthode main() de la classe TestLivre.

Exercice 4

1) Contrôle des variables private par les modificateurs

a- Ajoutez un prix aux livres (nombre qui peut avoir 2 décimales ; type Java float ou double) avec 2
méthodes getPrix et setPrix pour obtenir le prix et le modifier.

b- Ajoutez au moins un constructeur qui prend le prix en paramètre.

Mlle I.SGHAIER 36
 POO – ENCAPSULATION ET SURCHARGE

c- Testez. Si le prix d'un livre n'a pas été fixé, la description du livre (toString()) devra indiquer "Prix
pas encore fixé".
d- On bloque complètement les prix : un prix ne peut être saisi qu'une seule fois et ne peut être
modifié ensuite (une tentative pour changer le prix ne fait qu'afficher un message d'erreur).
Réécrivez la méthode setPrix (et autre chose si besoin est). Vous ajouterez une variable booléenne
prixFixe (pour "prix fixé") pour savoir si le prix a déjà été fixé.
e- Réécrire la méthode main () et prévoir le deux cas ( prix non fixé ou bien prix fixé plusieurs fois )
afficher le résultat de l’exécution.

Mlle I.SGHAIER 37
 POO – HERITAGE

CHAPITRE 4 :

L’HERITAGE

Objectifs spécifiques
1. Introduire la technique d’héritage : intérêt et notation
2. Introduire les droits d’accès d’une classe dérivée aux membres de la classe de base
3. Comprendre la construction d’un objet dérivé
4. Maîtriser la notion de redéfinition
5. Découvrir le concept de dérivations multiples

Eléments de contenu
I. L’encapsulation
II. Modificateurs de visibilité et accès
III. Surcharge des méthodes

Volume Horaire :
Cours : 4 heures 30
Travaux Pratiques : 6 heures

4.1 Le principe de l'héritage

L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution. Grâce à
l'héritage, les objets d'une classe ont accès aux données et aux méthodes de la classe parent et peuvent les
étendre. Les sous classes peuvent redéfinir les variables et les méthodes héritées. Pour les variables, il suffit
de les redéclarer sous le même nom avec un type différent. Les méthodes sont redéfinies avec le même
nom, les mêmes types et le même nombre d'arguments, sinon il s'agit d'une surcharge. L'héritage successif
de classes permet de définir une hiérarchie de classe qui ce compose de super classes et de sous classes.
Une classe qui hérite d'une autre est une sous classe et celle dont elle hérite est une super_classe. Une
classe peut avoir plusieurs sous classes. Une classe ne peut avoir qu'une seule classe mère : il n'y a pas
d'héritage multiple en java.
Object est la classe parente de toutes les classes en java. Toutes les variables et méthodes contenues
dans Object sont accessibles à partir de n'importe quelle classe car par héritage successif toutes les classes
héritent d'Object.

4.2 Syntaxe

Mlle I.SGHAIER 38
 POO – HERITAGE

class Fille extends Mere { ... }

On utilise le mot clé extends pour indiquer qu'une classe hérite d'une autre. En l'absence de ce mot
réservé associé à une classe, le compilateur considère la classe Object comme classe parent.
Exemple
//Classe de base
class graphique {
private int x, y;
graphique (int x, int y) {this.x = x ; this.y = y ;}
void affiche () {
System.out.println (`` Le centre de l’objet se trouve dans : » + x + « et
» + y) ;}
double surface () {return (0) ;}
} // fin de la classe graphique
//Classe dérivée1
class Cercle extends graphique {
private double rayon =1 ;
void affiche () {
Sustem.out.println (« C’est un cercle de rayon » + rayon) ;
Super.affiche () ;}
double surface ()
{return (rayon * 2* 3.14) ;} }
//Classe dérivée2
class Rectangle extends graphique {
private int larg, longueur ;
Rectangle ( int x, int y, int l1, int l2)
{super (x,y) ;
longueur = l1 ; larg = l2 ;}
double surface () {return (longueur*largeur) ;}
}// fin de la classe Rectangle
//Classe dérivée3
class carré extends graphique {
private double côté ;
Carré (double c, int x, int y) {
Super ( x,y) ;
Côté = c ;}
Double surface () {return (côté * côté) ;}
}// fin de la classe carré
Interprétation
1. Dans cet exemple, la classe Cercle hérite de la classe graphique les attributs et les méthodes,
redéfinit les deux méthodes surface et affiche et ajoute l’attribut rayon.

Mlle I.SGHAIER 39
 POO – HERITAGE

2. La classe Rectangle redéfinit la méthode surface et ajoute les attributs longueur et larg
3. La classe carré ajoute l’attribut côté et redéfinit la méthode surface.
Remarques
Le concept d’héritage permet à la classe dérivée de :
1. Hériter les attributs et les méthodes de la classe de base.
2. Ajouter ses propres définitions des attributs et des méthodes.
3. Redéfinir et surcharger une ou plusieurs méthodes héritées.
4. Tout objet peut être vu comme instance de sa classe et de toutes les classes dérivées.
5. Toute classe en Java dérive de la classe Object.
6. Toute classe en Java peut hériter directement d’une seule classe de base. Il n’y a pas la notion
d’héritage multiple en Java, mais il peut être implémenté via d’autres moyens tels que les interfaces
(Chapitre suivant).
Pour invoquer une méthode d'une classe parent, il suffit d'indiquer la méthode préfixée par super. Pour
appeler le constructeur de la classe parent il suffit d'écrire super(paramètres) avec les paramètres adéquats.
Le lien entre une classe fille et une classe parent est géré par le langage : une évolution des règles de
gestion de la classe parent conduit à modifier automatiquement la classe fille dès que cette dernière est
recompilée.
En java, il est obligatoire dans un constructeur d'une classe fille de faire appel explicitement ou
implicitement au constructeur de la classe mère.

4.3 L'accès aux propriétés héritées

Les variables et méthodes définies avec le modificateur d'accès public restent publiques à travers l'héritage
et toutes les autres classes.
Une variable d'instance définie avec le modificateur private est bien héritée mais elle n'est pas accessible
directement, elle peut l’être via les méthodes héritées.
Si l'on veut conserver pour une variable d'instance une protection semblable à celle assurée par le
modificateur private, il faut utiliser le modificateur protected. La variable ainsi définie sera hérité dans
toutes les classes descendantes qui pourront y accéder librement mais ne sera pas accessible hors de ces
classes directement.
Exemple1 : La classe dérivée et la classe de base sont dans le même package
package Formes_geo ;
class graphiques {
private x, y ;
public String couleur ;
void affiche () {
System.out.println (« Le centre de l’objet = ( » + x + « , » + y + « ) » ) ; }
double surface ( ) {return (0) ;} } //fin de la classe graphiques

Mlle I.SGHAIER 40
 POO – HERITAGE

package Formes_geo ;
class cercle extends graphiques{
double rayon ;
void changer_centre ( int x1, int y1, double r)
{x = x1 ; y = y1 ;
// faux car x et y sont déclarés private dans la classe de base
rayon =r ;
public double surface ( ) {return (rayon * 2* 3.14) ;}
public void affichec ()
{affiche () ;
// juste car le modificateur de visibilité de ce membre est freindly
System.out.println (« Le rayon = » + rayon + « La couleur = « + couleur ) ;}
}

Interprétation :
Dans le premier cas, la classe dérivée est la classe de base sont dans le même package, donc la classe
cercle a pu accéder aux membres (attributs et méthodes) publiques (l’attribut couleur), de même elle a pu
accéder aux membres « freindly » c'est-à-dire qui n’ont pas un modificateur de visibilité (la méthode
affiche), mais elle n’a pas pu accéder aux membres privés (x et y).

Exemple 2 : La classe dérivée et la classe de base ne sont pas dans le même package
package Formes_geo ;
class graphiques {
private x, y ;
public String couleur ;
void affiche () {
System.out.println (« Le centre de l’objet = ( » + x + « , » + y + « ) » ) ; }
double surface ( ) {return (0) ;} } //fin de la classe graphiques
package FormesCirc ;
class cercle extends graphiques{
double rayon ;
void changer_centre ( int x1, int y1, double r)
{x = x1 ; y = y1 ; // faux car x et y sont déclarés private dans la classe de base
rayon =r ;
public double surface ( ) {return (rayon * 2* 3.14) ;}
public void affichec ()
{affiche () ; // FAUX car le modificateur de visibilité de ce membre est freindly

Mlle I.SGHAIER 41
 POO – HERITAGE

System.out.println (« Le rayon = » + rayon + « La couleur = « + couleur ) ;}

}
Interprétation :
7. Dans le deuxième cas, la classe dérivée est la classe de base ne sont pas dans le même package,
donc la classe cercle a pu accéder aux membres (attributs et méthodes) publiques (l’attribut
couleur), mais, elle n’a pas pu accéder aux membres « freindly » c'est-à-dire qui n’ont pas un
modificateur de visibilité (la méthode affiche) et aux membres privés (x et y).
 Nous avons déjà vu qu’il existe 3 types de modificateurs de visibilité
publiques (« public »), privés (private) et de paquetage ou freindly (sans mention).
 Il existe encore un quatrième droit d’accès dit protégé (mot clé « protected »).

4.4 Construction et initialisation des objets dérivés

En java, le constructeur de la classe dérivée doit prendre en charge l’intégralité de la construction de

l’objet.
Si un constructeur d’une classe dérivée appelle un constructeur d’une classe de base, il doit
obligatoirement s’agir de la première instruction du constructeur. Le constructeur de la classe de base est
désigné par le mot clé « super ».
Exemple
class graphiques {
private x, y ;
public graphiques (int x1, int y1) {x = x1 ; y=y1 ;}
//autres méthodes
}
class cercle extends graphiques{
private double rayon ;
cercle ( int a, int b, double r) {
super (a, b) ;
//appelle le constructeur de la classe de base
rayon = r ; }
//autres méthodes
}

Remarque
Dans le cas général, une classe de base et une classe dérivée possèdent chacune au moins un constructeur.
Le constructeur de la classe dérivée complète la construction de l’objet dérivé, et ce, en appelant en
premier lieu le constructeur de la classe de base.
Toutefois, il existe des cas particuliers qui sont :
cas1 : La classe de base ne possède aucun constructeur

Mlle I.SGHAIER 42
 POO – HERITAGE

Dans ce cas, si la classe dérivée veut définir son propre constructeur, elle peut
optionnellement appeler dans la 1ère instruction de constructeur la clause « super () » pour
désigner le constructeur par défaut de la classe de base.
Cas2 : La classe dérivée ne possède pas un constructeur
Dans ce cas, le constructeur par défaut de la classe dérivée doit initialiser les attributs de la
classe dérivée et appeler :
- Le constructeur par défaut de la classe de base si elle ne possède aucun
constructeur.
- Le constructeur sans argument si elle possède au moins un constructeur.
- Dans le cas où il n’ y a pas un constructeur sans argument et il y a d’autres
constructeurs avec arguments, le compilateur génère des erreurs.
Exemple1 (cas1)
Class A {
// pas de constructeur
}
class B extends A {
public B(….)
{super() ; //appel de constructeur par défaut de A
………
}
B b = new B(…); // Appel de constructeur1 de A

Exemple2 (cas2)
Class A {
public A() {….} //constructeur1
public A ( int n) {…..} //constructeur2
}
class B extends A {
// …..pas de constructeur
}
B b = new B(); // Appel de constructeur1 de A

Exemple3 (cas 2)
Class A {
public A ( int n) {…..} //constructeur1
}
class B extends A {
// …..pas de constructeur
}

Mlle I.SGHAIER 43
 POO – HERITAGE

B b = new B();
/* On obtient une erreur de compilation car A ne dispose pas
un constructeurs sans argument et possède un autre constructeur*/

Exemple4 (cas1 et 2)
Class A {
//pas de constructeurs
}
class B extends A {
//pas de constructeurs
}
B b = new B ();
// Appel de constructeur par défaut de B qui Appelle le constructeur par
//défaut de A.

4.5 Dérivations successives

D’une même classe peuvent être dérivées plusieurs classes différentes.

Les notions de classe de base et de classe dérivée sont relatives puisqu’une classe dérivée peut, à son tour
servir de base pour une autre classe. Autrement dit, on peut rencontrer des situations telles que

 La classe Caniche est une classe descendante directement de la classe Chien et une classe
descendante de Animal
 La notion de l’héritage multiple n’existe pas directement en Java, mais elle peut être implémentée
via la notion des interfaces

4.6 Redéfinition et surcharge de membres

Mlle I.SGHAIER 44
 POO – HERITAGE

Nous avons déjà étudié la notion de surcharge (surdéfinition) de méthode à l’intérieur d’une même classe.
Nous avons vu qu’elle correspondait à des méthodes de même nom, mais de signatures différentes. Nous
montrerons ici comment cette notion se généralise dans le cadre de l’héritage : une classe dérivée pourra à
son tour surcharger une méthode d’une classe ascendante. Bien entendu, la ou les nouvelles méthodes ne
deviendront utilisables que par la classe dérivée ou ses descendantes, mais pas par ses ascendantes.
De même une classe dérivée peut fournir une nouvelle définition d’une méthode de même nom et aussi de
même signature et de même type de retour.
=>Alors que la surcharge cumule plusieurs méthodes de même nom, la redéfinition substitue une
méthode à une autre.

4.6.1 Redéfinition d’une méthode

La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent
(type et nombre de paramètres, la valeur de retour et les exceptions propagées doivent être identiques) et
fournir dans une sous-classe une nouvelle implémentation de la méthode. Cette nouvelle implémentation
masque alors complètement celle de la super-classe. Si la signature de la méthode change, ce n'est plus une
redéfinition mais une surcharge.
Remarques
 La re-déclaration doit être strictement identique à celle de la super-classe : même nom, même
paramètres et même type de retour.
 Grâce au mot-clé super, la méthode redéfinie dans la sous-classe peut réutiliser du code écrit
dans la méthode de la super-classe, qui n’est plus visible autrement.
Exemple
//Super-classe
class graphiques {
private x, y ;
public String couleur ;
public void affiche () {
System.out.println (« Le centre de l’objet = ( » + x + « , » + y + « ) » ) ; }
double surface ( ) {return (0) ;} } //fin de la classe graphiques

//classe dérivée
class cercle extends graphiques{
double rayon ;
public double surface ( ) {
return (rayon * 2* 3.14) ;} //redéfinition de « surface »
public void affiche () //redéfinition de la méthode « affiche »
{super.affiche () ; // appel de affiche de la super-classe

Mlle I.SGHAIER 45
 POO – HERITAGE

System.out.println (« Le rayon = » + rayon + « La couleur = « + couleur ) ;}

}

4.6.2 Redéfinition de méthode et dérivations successives

Soit l’arborescence suivante :

La présence d’un astérisque (*) signale la définition ou la redéfinition d’une méthode f

A*

C*
B

D* E F
L’appel de la fonction f conduira pour chaque classe à l’appel de la méthode indiquée :
Classe A : Méthode f de A
Classe B : Méthode f de A
Classe C : Méthode f de C
Classe D : Méthode f de D
Classe E : Méthode f de A
Classe F : Méthode f de C

4.6.3 Surcharge des méthodes

En Java, une méthode dérivée peut surcharger une méthode d’une classe ascendante
Exemple
Class A
{public void f (int n) {…..}
…}

Class B extends A
{public void f (float n) {…..}
…}
Aa,Bb;
int n; float x;
a.f(n) // appelle f(int) de A
a.f(x) // Erreur, on a pas dans A f(float)
b.f(n) // appelle f(int) de A

Mlle I.SGHAIER 46
 POO – HERITAGE

b.f(x) // appelle f(float) de B

4.6.4 Utilisation simultanée de surcharge et de redéfinition

Class A
{public void f (int n) {…..}
public void f (float n) {…..}
…}
Class B extends A
{public void f (int n) {…..} // redefinition de la
méthode f( int ) de A
public void f (double n) {…..} // Surcharge de la
méthode f de A et de B
…}
Aa,Bb;
int n , float x, double y ;
a.f(n) ;//Appel de f(int) de A
a.f(x) ;//Appel de f(float) de A
a.f(y) ; //Erreur, il n’ y a pas f(double) dans A
b.f(n) ;
//Appel de f(int) de B car f(int) est redéfinie dans B
a.f(x) ;//Appel de f(float) de A
a.f(y) ;//Appel de f(double) de B

4.6.3 Règles générales de redéfinition

- Si une méthode d’une classe dérivée a la même signature q’une méthode d’une classe ascendante :
 Les 2 méthodes doivent avoir le même type de retour.
 Le droit d’accès de la méthode de la classe dérivée ne doit pas être moins élevé que celui de la classe
ascendante.
- Une méthode statique ne peut pas être redéfinie.

4.7 Autres mots clés «final » et « super »

 Le mot clé « super »

- Le mot clé « super » peut être utilisé pour :
* appeler un constructeur de la classe de base dans le constructeur de la classe dérivée. Cet appel
doit être la 1ère instruction dans le constructeur de la classe dérivée.
Syntaxe : super (<liste des arguments>).

Mlle I.SGHAIER 47
 POO – HERITAGE

* Accéder dans une méthode d’une classe dérivée à une méthode de la super-classe (optionnel
sauf dans le cas de redéfinition)
Syntaxe : super.nom_méthode (<liste des arguments>) ;
*Accéder dans une méthode dérivée à un attribut de la classe de base (optionnel)
Syntaxe : super.nom_attribut

 Le modificateur « final »
Cas1 : Le modificateur « final » placé devant une classe interdit sa dérivation
Exemple
final class A {
//Méthodes et attributs }
class B extends A //Erreur car la classe A est déclarée finale
{//....}
Cas 2 : Le modificateur « final » placé devant une méthode permet d’interdire sa redéfinition
Class A {
final Public void f(int x) {…..}
//…Autres méthodes et attributs
}
Class B {
//Autres méthodes et attributs
public void f (int x) {…} // Erreur car la méthode f est déclarée finale. Pas de redéfinition
}
Les classes et les méthodes peuvent être déclarées finales pour des raisons de sécurité pour garantir que
leur comportement ne soit modifié par une sous-classe.

4.8 Des conseils sur l'héritage

Lors de la création d'une classe « mère » il faut tenir compte des points suivants :
 la définition des accès aux variables d'instances, très souvent privées, doit être réfléchie entre
protected et private ;
 pour empêcher la redéfinition d'une méthode (surcharge) il faut la déclarer avec le modificateur
final. Lors de la création d'une classe fille, pour chaque méthode héritée qui n'est pas final, il faut
envisager les cas suivant :
 la méthode héritée convient à la classe fille : on ne doit pas la redéfinir ;
 la méthode héritée convient mais partiellement du fait de la spécialisation apportée par la classe
fille : il faut la redéfinir voir la surcharger. La plupart du temps une redéfinition commencera par
appeler la méthode héritée (via super) pour garantir l'évolution du code ;
 la méthode héritée ne convient pas : il faut redéfinir ou surcharger la méthode sans appeler la
méthode héritée lors de la redéfinition.

Mlle I.SGHAIER 48
 POO – POLYMORPHISME

CHAPITRE 5 :

LE POLYMORPHISME

Objectifs spécifiques
1. comprendre Le concept de polymorphisme à travers des exemples
2. Comprendre la conversion des arguments en liaison avec le polymorphisme
3. Comprendre la conversion explicite des références en rapport avec le polymorphisme

Eléments de contenu
I. Concept de polymorphisme
II. Exemple et interprétation
III. Conversion des arguments effectifs
IV. Les conversion explicites des références

Volume Horaire :
Cours : 3 heures
Travaux Pratiques : 3 heures

5.1 Concept de polymorphisme

 Le polymorphisme est un concept extrêmement puissant en POO, il permet de manipuler des objets
sans en connaître tout à fait le type tout en se basant sur la relation d’héritage.
 Le polymorphisme en Java, se traduit par :
 La compatibilité entre un type dérivée et un type ascendant.
 La ligature dynamique des méthodes, dans le sens où il permet d’obtenir le comportement
adapté à chaque type d’objet, sans avoir besoin de tester sa nature de quelque façon que ce
soit.
 Le polymorphisme se base sur cette affirmation : un objet a comme type non seulement sa classe
mais aussi n’importe quelle classe dérivée.

5.2 Exemples et interprétations

Exemple 1
//Classe de base
class graphique {

Mlle I.SGHAIER 49
 POO – POLYMORPHISME

private int x, y;
public graphique ( int x, int y) { this.x = x ; this.y = y ;}
public void identifie () {
System.out.println (« Je suis une forme géometrique ») ;}
public void affiche () {
this.identifie() ;
System.out.println (« Le centre de l’objet se trouve dans : » + x
+ « et » + y) ;}
double surface () {return (0) ;}
} // fin de la classe graphique
//Classe dérivée1
class Cercle extends graphique {
private double rayon =1 ;
public Cercle ( int x, int y, double r) {super(x,y) ;
rayon = r ;}
public void identifie () {
System.out.println (« Je suis un cercle ») ;}
double surface ()
{return ( rayon * 2* 3.14) ;} }
//Classe dérivée2
class Rectangle extends graphique {
private int larg, longueur ;
Rectangle ( int x, int y, int l1, int l2)
{super (x,y) ;
longueur = l1 ; larg = l2 ;}
double surface () {return (longueur*largeur) ;}
public void identifie() {
System.out.println(« Je suis un rectangle ») ;}
}// fin de la classe Rectangle
//Classe de test
class test_poly {
public static void main (String [] args) {
graphique g = new graphique (3,7);
g.identifie ();
g= new Cercle (4,8,10) ;
// compatibilité entre le type de la classe et de la classe dérivéé
g.identifie() ;

Mlle I.SGHAIER 50
 POO – POLYMORPHISME

g= new Rectangle (7,9,10,3) ;

// compatibilité entre le type de la classe et de la classe dérivéé
g.identifie () ;
}
}
Résultat de l’exécution
Je suis une forme géométrique
Je suis un cercle
Je suis un rectangle
Interprétation
Le même identificateur « g » est initialisé dans la 1ère instruction avec une référence de type « graphique »,
puis on a changé la référence de cette variable dans l’instruction3 en lui affectant une référence de type
« Cercle », puis dans l’instruction 5, on a changé sa référence avec une référence de classe dérivée
« Rectangle ».
Ces affectations confirment la compatibilité entre un type d’une classe de base et la référence d’une classe
dérivée.
L’autre point qui semble plus important c’est la ligature dynamique des méthodes, dans le sens où le
résultat de la méthode « identifie » a changé dans chaque appel selon le type effectif de la variable « g ».
Exemple 2 : Tableau des objets
Dans cet exemple, on va exploiter les possibilités de polymorphisme pour créer un tableau hétérogène
d’objets, c’est à dires dans lequel les éléments peuvent être de types différents.
class test_poly2 {
public static void main (String [] args) {
graphique [] tab = new graphique [6];
tab[0] = new graphique (3,2);
tab[1] = new Cercle (10,7,3) ;
tab [2] = new Rectangle (4,7,8,6) ;
tab [3] = new graphique (8,10);
tab[4] = new Cercle (8,5,3) ;
tab[5 = new Rectangle (10,17,3,8) ;
for (i=0 ; i <=5 ; i++) {tab[i].affiche();}
}
}
Résultat de l’exécution
Je suis une forme géométrique Le centre de l'objet se trouve dans : 3 et 2
Je suis un cercle Le centre de l'objet se trouve dans : 10 et 7
Je suis un rectangle Le centre de l'objet se trouve dans : 4 et 7
Je suis une forme géométrique Le centre de l'objet se trouve dans : 8 et 10

Mlle I.SGHAIER 51
 POO – POLYMORPHISME

Je suis un cercle Le centre de l'objet se trouve dans : 8 et 5

Je suis un rectangle Le centre de l'objet se trouve dans : 10 et 17
Exemple 3
class test_poly3 {
public static void main (String [] args) {
String c ;
graphique d;
int c= Integer.parseInt(args [0]) ;
switch (c) {
case 0 : d=new Cercle (10,10,10) ; break;
case 1 : d=new Rectangle (10,10,10,10) ; break;
case 2 : d= new graphique (10,10); break;
default: d= new graphique (0,0);
}
d.identifie () ;
System.out.println (« Surface = » + d.surface()) ;
}
}
Résultat de l’exécution :
Le message affiché est en fonction de l’argument introduit dans la commande d’exécution.
Le gros avantage du polymorphisme est de pouvoir référencer des objets sans connaître à la compilation
véritablement leur classe et de pouvoir par la suite à l’exécution lancer le code approprié à cet objet. La
liaison entre l’identificateur de la méthode polymorphe et son code est déterminée à l’exécution et non à la
compilation, on parle alors de liaison dynamique.
Remarque :
8. Le polymorphisme se base essentiellement sur le concept d’héritage et la redéfinition des
méthodes. Toutefois, si dans le même contexte d’héritage, on a à la fois une redéfinition et une
surcharge de la même méthode, les règles de polymorphisme deviennent de plus en plus
compliquées.
9. La notion de polymorphisme peut être généralisée dans le cas de dérivations successives.

5.3 Conversion des arguments effectifs

La conversion d’un type dérivé en un type de base est aussi une conversion implicite légale, elle va donc
être utilisée pour les arguments effectifs d’une méthode.
Exemple1
class A
{public void identifie()
{System.out.println (« Objet de type A ») ; }
}

Mlle I.SGHAIER 52
 POO – POLYMORPHISME

class B extends A
{// pas de redéfinition de identitie ici
}
class Test
{ static void f(A a ) {
a.identitie(); }
}
…..
A a = new A();
B b = new B ();
Test.f(a);
// OK Appel usuel; il affiche “objet de type A”
Test.f(b) ;
/*OK une référence à un objet de type B est compatible avec une
référence à un objet de type A. L’appel a.identifie affiche : « Objet
de type A » */
Exemple2
On va juste modifier le corps de la classe B par une redéfinition de la méthode « identifie »
class B {
public void identifie () {
System.out.println (« Objet de type B ») ;}
}
….
A a = new A(); B b = new B ();
Test.f (b) ;
/*OK une référence à un objet de type B est compatible avec une
référence à un objet de type A. L’appel a.identifie affiche : « Objet
de type B »*/

Cet exemple, montre que comme dans les situations d’affectation, la conversion implicite d’un type dérivé
dans un type de base n’est pas dégradante puisque grâce au polymorphisme, c’est bien le type de l’objet
référencé qui intervient.
Remarque :
Dans le cas où la méthode f est surdefinie, il y a encore des règles plus compliquées lors de la conversion
implicite des types de paramètres.

5.4 Les conversions explicites de références

Mlle I.SGHAIER 53
 POO – POLYMORPHISME

Compatibilité entre référence à un objet d’un type donné et une référence à un objet d’un type ascendant.
Dans le sens inverse, la compatibilité n’est pas implicite.
Exemple :
Class graphique {…….}
Class Cercle {……..}
…..
graphique g,g1 ;
Cercle c,c1 ;
C = new graphique (….) ; //Erreur de compilation
g= new Cercle (…) //Juste
g1 = new graphique (….) ; //évident
c1= new Cercle(…) ; //évident
c1 = g1 //faux (Conversion implicite illégale)
g1= c1 ; //juste ; (conversion implicite légale)
Il faut réaliser une conversion explicite c1 = (Cercle) g1 ;
Toutefois cette syntaxe qui est acceptée à la compilation peut être refusée à l’exécution et le traitement
peut être arrêtée si il n ‘y a pas compatibilité effective entre les types.

Mlle I.SGHAIER 54
 POO – POLYMORPHISME

TD2

Exercice 1: Gestion de comptes en banque

Une banque gère un ensemble de comptes de différents types : comptes courant, comptes d’épargne…
Les comportements et les caractéristiques liés à un compte sont à un niveau abstrait fort similaires :
chacun possède un propriétaire, un solde, un numéro, un taux d’intérêt : on y peut déposer de l’argent,
retirer de l’argent (s’il en reste suffisamment)
La banque propose également un système d’emprunts. Chaque emprunt est caractérisé par le montant
total à rembourser, la valeur des mensualités et le compte duquel les mensualités doivent être débitées
Le but de cet exercice consiste à créer une banque et à tenir à jour l’état des comptes en fonction des
retraits, des intérêts et des remboursements d’emprunts sur chaque compte.

Exercice 2
Un fichier est caractérisé par : son nom, son extension, son emplacement et sa taille sur disque (en kilo
octets).
Les fichiers sont enregistrés dans des supports magnétiques pouvant être des disquettes ou des disques
durs
Une disquette est caractérisée par son nom logique, la taille d’un secteur en kilo octets, le nombre de
secteurs par pistes et le nombre de pistes par surface.
Un disque dur est caractérisé par son nom logique, la taille d’un secteur en kilo octets, le nombre de
secteurs par piste, le nombre de pistes par surfaces et le nombre de surfaces.
Afin de pouvoir gérer son contenu, on suppose que chaque disque contient deux tableaux
 Le premier contient toutes les caractéristiques d’un fichier donné
 Le second contient pour chaque fichier son adresse physique (les adresses physiques sont attribuées
automatiquement par le système)
On se propose alors de développer les classes Fichier, Disquette et DisqueDur :
La classe Fichier doit contenir :
 Un constructeur paramétré qui accepte comme arguments une liste de valeurs permettant
l’initialisation des différents attributs de l’objet en question;
 Des mutateurs permettant la modification des valeurs des attributs d’un objet;
 Des accesseurs permettant le renvoi des valeurs des attributs d’un objet;
Chacune des deux classes Disquette et DisqueDur doit contenir :
 Un constructeur paramétré qui accepte comme arguments une liste de valeurs permettant
l’initialisation des différents attributs de l’objet en question;

Mlle I.SGHAIER 55
 POO – POLYMORPHISME

 Une méthode getEspaceDisque() permettant de calculer et de retourner la taille totale du disque

concerné (en kilo octets)
 Une méthode getEspaceLibre() permettant de calculer et de retourner l’espace libre dans un
disque (en kilo octets)
 Une méthode ajouterFichier() permettant d’ajouter un fichier donné (ajouter un fichier revient
tout simplement à l’insérer à la fin du tableau si la taille de disque suffit, on s’occupe pas de l’adresse ou il
sera stocké)
 Une méthode explorerExtension() permettent d’afficher tous les fichiers (nom, extension,
emplacement et taille) ayant comme extension celle qui est introduite comme paramètre.
Dans le but d’expérimenter le comportement de toutes les classes déjà développées on se propose
d’ajouter une nouvelle classe nommée Application basée principalement sur la méthode main (). Dans
cette méthode principale on doit :
 Construire les fichiers suivants :
 (Nom : " examen " ; Extension : " doc " ; Taille 2 kilo ; Emplacement : " C:\word ")
 (Nom : " bulletin " ; Extension : " xls " ; Taille 1 kilo ; Emplacement : " C:\excel ")
 (Nom : " nature " ; Extension : " gif "; Taille 25 kilo ; Emplacement : " C : ")
 construire le disque dur suivant :
(Nom logique : " C : "; Taille d’un secteur : 0.9375 kilo octet ; Nombre de surfaces: 16 ; Nombre
de piste par surface : 1024 ; Nombre de secteurs par pistes : 520)

 ajouter tous les fichiers crées à ce disque

 afficher les noms des fichiers ayant comme extension « doc ».

Mlle I.SGHAIER 56
 POO – CLASSES ABSTRAITES ET INTERFACES

CHAPITRE 6 :

LES CLASSES ABSTRAITES ET LES INTERFACES

Objectifs spécifiques
1. Introduire la notion de classe abstraite, les règles de définition et l’intérêt pratique
2. Introduire le concept d’interfaces, leurs intérêts pratiques et leurs relations avec l’héritage

Eléments de contenu
I. Les classes abstraites
II. Les interfaces

Volume Horaire :
Cours : 3 heures
Travaux Pratiques : 3 heures

6.1 Les classes abstraites

6.1.1 Concept des classes abstraites

- Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle ne peut servir que de
classe de base pour une dérivation.

- Dans une classe abstraite, on peut trouver classiquement des méthodes et des champs, dont héritera
toute classe dérivée et on peut trouver des méthodes dites « abstraites » qui fournissent uniquement la
signature et le type de retour.

Syntaxe

abstract class A

{public void f() {……} //f est définie dans A

public abstract void g (int n) ; //g est une méthode abstraite elle
n’est pas définie dans A

Utilisation

Aa;

//on peut déclarer une référence sur un objet de type A ou dérivé

a = new A (….) ;

Mlle I.SGHAIER 57
 POO – CLASSES ABSTRAITES ET INTERFACES

//Erreur pas d’instanciation d’objets d’une classe abstraite

Si on dérive une classe B de A qui définit les méthodes abstraites de A, alors on peut :

a = new B(…) ; //Juste car B n’est pas une classe abstraite

6.1.2 Règles des classes abstraites

 Dès qu’une classe abstraite comporte une ou plusieurs méthodes abstraites, elle est abstraite, et ce
même si l’on n’indique pas le mot clé « abstract » devant sa déclaration.

 Une méthode abstraite doit être obligatoirement déclarée « public », ce qui est logique puisque sa
vacation est d’être redéfinie dans une classe dérivée.

 Les noms d’arguments muets doivent figurer dans la définition d’une méthode abstraite

public abstract void g(int) ;

//Erreur : nom argument fictif est obligatoire

 Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir toutes les méthodes abstraites,
elle peut ne redéfinir aucune, mais elle reste abstraite tant qu’il y a encore des méthodes abstraites non
implémentées.

 Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.

6.1.3 Intérêt des classes abstraites

Le recours aux classes abstraites facilite largement la conception orientée objet. On peut placer dans une
classe abstraite toutes les fonctionnalités dont on souhaite disposer pour les classes descendantes :

● Soit sous la forme d’une implémentation complète de méthodes (non abstraites) et de champs
(privés ou non) lorsqu’ils sont communs à tous les descendants,

● Soit sous forme d’interface de méthodes abstraites dont on est alors sûr qu’elles existeront dans
toute classe dérivée instanciable.

6.1.4 Exemple

abstract class graphique {

private int x, y;

graphique ( int x, int y) { this.x = x ; this.y = y ;}

void affiche () {

System.out.println (« Le centre de l’objet se trouve dans : » + x + « et

» + y) ;}

Mlle I.SGHAIER 58
 POO – CLASSES ABSTRAITES ET INTERFACES

Abstract public double surface () ; // méthode abstraite

} // fin de la classe graphique

//Classe dérivée1

class Cercle extends graphique {

private double rayon =1 ;

void affiche () {

Sustem.out.println (« C’est un cercle de rayon » + rayon) ;

Super.affiche() ; }

double surface ()

{return ( rayon * 2* 3.14) ;} }

//Classe dérivée2

class Rectangle extends graphique {

private int larg, longueur ;

Rectangle ( int x, int y, int l1, int l2)

{super (x,y) ;

longueur = l1 ; larg = l2 ;}

double surface () {return (longueur*largeur) ;}

}// fin de la classe Rectangle

// Classe de test

class test_poly2 {
public static void main (String [] args) {
graphique [] tab = new graphique [6];
//tab[0] = new graphique (3,2); Erreur car une classe abstraite ne peut
pas être instanciée
tab[0] = new Cercle (3,2,7);
tab[1] = new Cercle (10,7,3) ;
tab[2] = new Rectangle (4,7,8,6) ;
tab[3] = new Rectangle (8,10,12,10);
tab[4] = new Cercle (8,5,3) ;
tab[5] = new Rectangle (10,17,3,8) ;
for (int i=0 ; i <=5 ; i++) {tab[i].affiche();}
}
}

Mlle I.SGHAIER 59
 POO – CLASSES ABSTRAITES ET INTERFACES

=> Une classe abstraite peut ne comporter que des méthodes abstraites et aucun champ. Dans ce cas, on
peut utiliser le concept de l’interface.

6.2 Les interfaces

6.2.1 Concept d’interface

- Si on considère une classe abstraite n’implantant aucune méthode et aucun champ (sauf les
constantes), on aboutit à la notion d’interface.

- Une interface définit les entêtes d’un certain nombre de méthodes, ainsi que des constantes.

- L’interface est plus riche qu’un simple cas particulier des classes abstraites :

 Une classe peut implémenter plusieurs interfaces (alors qu’une classe ne pouvait dériver
que d’une seule classe abstraite).

 La notion d’interface va se superposer à celle de dérivation, et non s’y substitue.

 Les interfaces peuvent se dériver.

 Une classe dérivée peut implémenter 1 ou plusieurs interfaces, elle peut même
réimplémenter une interface déjà implémentée par la superclasse.

 On pourra utiliser des variables de type interface.

6.2.1 Syntaxe

6.2.1.1 Définition d’une interface

public interface I

{void f (int n) ; //public abstract facultatifs

void g () ; //public abstract facultatifs

Toutes les méthodes d’une interface sont abstraites. On peut ne pas mentionner le modificateur de
visibilité (par défaut public) et le mot clé « abstract »

6.2.1.2 Implémentation d’une interface

- Lorsqu’on définit une classe, on peut préciser qu’elle implémente une interface donnée en utilisant le
mot clé « implements ».

Syntaxe

Mlle I.SGHAIER 60
 POO – CLASSES ABSTRAITES ET INTERFACES

public interface I1

{….}

public interface I2

{…}

class A implements I1, I2

{…..A doit définir les méthodes de I1 et I2}

6.2.1.3 Exemple

interface Affichable

{void affiche() ;

class Entier implements Affichable

{private int val ;

public Entier (int n)

{val = n ;}

public void affiche() {

System.out.println (« Je suis un entier de valeur » + val) ;}

class Flottant implements Affichable

{private float val ;

public Flottant (float n)

{val = n ;}

public void affiche() {

System.out.println (« Je suis un flottant de valeur » + val) ; }

public class TestInterface {

public static void main (String [] args) {

Afficheable [] tab = new Afficheable [2];

tab[0] = new Entier (25);

Mlle I.SGHAIER 61
 POO – CLASSES ABSTRAITES ET INTERFACES

tab [1] = new Flottant (1.25);

tab [0].affiche(); tab [1].affiche; } }

Résultat de l’exécution

- Je suis un entier de valeur 25

- Je suis un flottant de valeur 1.25

6.2.1.4 Interface et constantes

Une interface peut renfermer aussi des constantes symboliques qui seront accessibles à toutes les classes
implémentant l’interface :

public interface I

{void f (int n) ; //public abstract facultatifs

void g () ; //public abstract facultatifs

static final int max = 100 ;

Les constantes déclarées sont toujours considérées comme « static » et « final »

6.3 Interface et dérivations

Remarque

L’interface est totalement indépendante de l’héritage : Une classe dérivée peut implémenter une ou
plusieurs interfaces.

Exemple

interface I1 {…..}

interface I1 {…..}

class A implements I1 {……}

class B extends A implements I1, I2 {…..}

Remarque2

On peut définir une interface comme une généralisation d’une autre. On utilise alors le mot clé « extends »

Exemple

interface I1

{void f(int n) ;

static final int max = 100;

Mlle I.SGHAIER 62
 POO – CLASSES ABSTRAITES ET INTERFACES

interface I2 extends I1

{void g (int n);

static final int min = 10;

En fait la définition de I2 est équivalente à

interface I2

{void g (int n);

static final int min = 10;

void f(int n) ;

static final int max = 100;

Remarque3
- Conflits des noms

Soit l’exemple suivant

interface I1

{void f(int n) ;

void g();

interface I2

{void f (float x);

void g();

class A implements I1, I2

{ /*A doit implémenter la méthode g qui existe dans les 2

interfaces une seule fois*/}

->Supposons que la méthode « g » est présente de 2 façons différentes dans I1 et I2

Exemple

Mlle I.SGHAIER 63
 POO – CLASSES ABSTRAITES ET INTERFACES

interface I1

{ void g(); } // g est une méthode abstraite de I1

interface I2

{ int g(); } // g est aussi une méthode abstraite de I2

class A implements I1, I2 {

/* Erreur car void g() et int g() ne peuvent pas coexister au sein
de la même classe*/

Mlle I.SGHAIER 64
 POO – LES EXCEPTIONS

CHAPITRE 7 :

LES EXCEPTIONS

Objectifs spécifiques
1. Introduire la notion d’exception, les règles d’utilisation et de définition des exceptions.
2. Distinguer entre les exceptions prédéfinies et les exceptions définies par l’utilisateur.

Eléments de contenu
I. Définition
II. Les exceptions prédéfinies
III. Les exceptions définies par l’utilisateur
IV. Exemple

Volume Horaire :
Cours : 1 heure 30
Travaux Dirigés : 1 heure

7.1 Définitions
La notion d’exception est offerte aux programmeurs Java pour résoudre de manière efficace et simple le
problème de la gestion des erreurs émises lors de l’exécution d’un programme.
Une exception est un signal qui indique qu’un événement anormal est survenu dans un programme
- La récupération (le traitement) de l’exception permet au programme de continuer son exécution.
- Une exception est un signal déclenché par une instruction et traité par une autre
• Il faut qu’un objet soit capable de signaler ou lever (throw) une exception à un autre objet
• Il faut que l’autre objet puisse saisir (catch) une exception afin de la traiter
Lorsque l’exception se produit le contrôle est transféré à un gestionnaire d’exceptions
- Séparation de l’exécution normale de l’exécution en cas de condition anormale

Exemple

Tester cet exemple en modifiant la valeur de j par 0

public class TestException {
public static void main(java.lang.String[] args) {

int i = 3;
int j = 1;

Mlle I.SGHAIER 65
 POO – LES EXCEPTIONS

try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("erreur division par zéro");

}
}
}

Une méthode qui désire gérer ce genre de problèmes peut indiquer qu’elle est disposée à intercepter
l’exception (instruction throws).

7.2 Les exceptions prédéfinies

- En Java, les exceptions sont de véritables objets.

- Ce sont des instances de classes qui héritent de la classe Throwable.
- Lorsqu’une exception est levée, une instance de la classe Throwable est créée.Voici un aperçu de
la hiérarchie des classes pour les exceptions.

Erreurs et Exceptions
• Erreur: indications de problèmes irrécupérables dus au matériel ou au système d’exploitation
• Exception: erreurs résiduelles dans le programme qui peuvent être traitées par une sortie propre ou une
récupération (arithmétique, pointeurs, index, i/o, etc.)

Mlle I.SGHAIER 66
 POO – LES EXCEPTIONS

- Les instances de la classe Error sont des erreurs internes à la machine virtuelle Java. Elles sont rares et
fatales.
- Les sous-classes de la classe Exception sont réparties en deux catégories :
- Les exceptions d’exécution (runtime) sont souvent l’effet du manque de robustesse du code. Par exemple
l’exception NullPointerException est levée lorsque l’on manipule un objet non instancié (oubli de
l’instruction new) ;
- Les autres exceptions correspondent à des événements anormaux échappant au contrôle du programme.
Par exemple, l’exception EOFException est levée si on essaie de lire au-delà d’un fichier.
 Traiter les exceptions levées : les mots clés try, catch et finally :

 Intercepter une exception : le mot clé throws : Si une méthode est susceptible de lever une exception
et si elle ne peut pas la traiter, elle se doit de prévenir le système qu'elle relaye cette tâche. Pour ce faire, on
utilise le mot clé throws dans la définition de la méthode. Ce mot clé permet d'avertir le système qu'une
certaine catégorie d'exception ne sera pas traitée en local (dans l'exemple suivant, l'ensemble des
exceptions liées aux entrées/sorties).
public void ma_methode (int x) throws IOEXception {
…
}

 Il est également possible de désigner l’interception de plusieurs exceptions :

public void ma_methode (int x) throws IOException, EOFException{
…
}

7.3 Les Exceptions définies par l’utilisateur

Jusqu’à présent on parlé des exceptions prédéfinies qui se déclenchent toutes seules. Java offre au
programmeur la possibilité de définir ses propres exceptions. Ces exceptions doivent hériter d’une autre
exception de la hiérarchie des classes Java. Le programmeur doit lui-même lever ses exceptions.

Mlle I.SGHAIER 67
 POO – LES EXCEPTIONS

Pour se faire Java met à sa disposition le mot-clé throw (à ne pas confondre avec throws). Pour le reste
(try, catch, finally) le mécanisme est identique.

7.4 Exemple

Voici un exemple avancé réalisé par l’éditeur Jbuilder, c’est en fait une interface utilisateur qui
permet l’insertion d’une date, en faisant les contrôles nécessaires pour afficher l’intitulé du jour.

Mlle I.SGHAIER 68
 POO – LES EXCEPTIONS

Appel à l’exception

public static void controlmois(int jour,int mois) throws SaisieDateException {

if (mois<1||mois>12)
{ throw new SaisieDateException("Mois invalid."); }

else{
if((mois==4||mois==6||mois==9||mois==11)&&(jour==31)){
throw new SaisieDateException("le jour du mois est invalid.");
}
else if(mois==2&&(jour==31||jour==30)){
throw new SaisieDateException("le jour du mois est invalid.");

}
}

Déclaration de l’exception

public class SaisieDateException extends Exception {

public SaisieDateException(String s) {
super(s);
}
Exercice

Mlle I.SGHAIER 69
 POO – LES EXCEPTIONS

Ecrire une méthode lireNombre() demandant un nombre à l’utilisateur, le lisant sous forme de chaîne de
caractère et le transformant ensuite en entier. La méthode doit recommander un nombre tant que l’entrée
est invalide.
NB : Les exceptions susceptibles d’être renvoyées par readline() est IOException et par parseInt() est
NumberFormatException
Solution :
import java.io.*;
public class Clavier {
//Méthode qui permet de lire une chaine de caractères
public static String lireString ()
{String ligne_lue = null;
try
{InputStreamReader lecteur = new InputStreamReader(System.in);
BufferedReader entree = new BufferedReader(lecteur);
ligne_lue = entree.readLine();
}
catch(IOException err)
{System.exit(0);
}
return ligne_lue;}

//Méthode qui permet de lire un entier

public static int lireInt()
{int x=0;
try
{String ligne_lue = lireString();
x=Integer.parseInt(ligne_lue);
}
catch (NumberFormatException err)
{System.out.println ("***Erreur de données***");
System.exit(0);
}
return x;
}
}

public class test {

public static void main(String[] argv) {
int x= clavier.lireInt();
System.out.println(">>>>>> "+ x);
} }

Mlle I.SGHAIER 70
 POO – ANNEXE

ANNEXE

71
 POO – ANNEXE

EXAMEN POO

Session : Juin 2008 Groupe : II3, IG3, RI3

Enseignants : Mlle Sghaier Imene, Mme Aloulou Narjes, Mr Rekik Rojdi  : Non autorisés
Durée : 1h30 Nb. Pages: 2

Enoncé :
Une société de vente par correspondance propose des articles dans différents rayon :
habillement, électro-ménager, vidéo/hi-fi et culturel. Chaque article est caractérisé par une
désignation (son nom), une référence (incrémenté de 1 pour un nouvel article), un descriptif, un
prix HT. Il est possible d’obtenir le prix TTC d’un article et d’afficher les informations le
concernant.
Les vêtements sont en plus définis par leur composition qui énumère les matières qui les
composent et dans quelles proportions. Le taux TVA sur les vêtements est de 19.6%. Les frais de
port sont 1 dinar par vêtement.
Les articles de l’électro-ménager et de la vidéo/hi-fi possèdent une consommation électrique, une
durée de garantie, un poids (en Kg) et des dimensions (l x h x p) en cm. Le taux TVA sur les
articles est de 19.6%. Les frais du port sont de 1 dinar tous les deux kilos majorés de 10% si le
volume de l’article dépasse 0.1 m3. La garantie est de 3 ans en électro-ménager et de 5 ans en
vidéo/hi-fi. Les articles culturels sont répartis entre livres et disques. La TVA sur les livres est de
5.5 % alors qu’elle est de 19.6 % sur les disques. Les frais de port sont nuls pour les produits
culturels.
Questions :

Développer toutes les classes en respectant le digramme de classes (Vente par

correspondance) ;
 Pour la composition des vêtements (la classe Composition), on peut utiliser une Map qui
pour chaque matière donne un pourcentage. N’oublier pas de vérifier que la somme des
pourcentages vaut 100.
Remarque :

La relation entre la classe X et Y sera traduite en java par :

X Y
1
public class X{
private Y y ;
public X(parameters of X){
y= new Y(parameters of Y) ;
}}

72
 POO – ANNEXE

Digramme de classe : Vente par correspondance

73
 POO – ANNEXE

EXAMEN POO

Session : Janvier 2008 Groupe : II3, IG3, RI3

Enseignants : Mlle Sghaier Imene, Mme Aloulou Narjes, Mr Rekik Rojdi  : Non autorisés
Durée : 1h30 Nb. Pages: 3

Enoncé :

Une agence de location de voitures offre à ses clients la possibilité de choisir la voiture
louée en fonction de différents critères.
Les voitures sont définies par une marque, un nom de modèle, une année de production et un
prix de location à la journée. Pour simplifier les deux premiers paramètres seront des objets de
la classe String et les deux derniers seront des int. Deux voitures sont considérées égales si
tous leurs attributs sont égaux.
La classe Voiture pour laquelle on souhaite disposer des méthodes habituelles equals et
toString. La méthode toString retournant une chaîne de caractères reprenant la marque, le
nom du modèle et le prix de location. La méthode equals teste si une voiture est égale à une
autre.
Il est possible de sélectionner parmi les voitures à louer toutes les voitures satisfaisant un
critère donné.
On définit l'interface Critere ainsi :
public interface Critere {
//@param v la voiture dont on teste la confirmité
// @return true si et seulement si la voiture est conforme au
//critère (on dit que v satisfait le critère)
public boolean estSatisfaitPar(Voiture v);
}
La classe Agence gère des locations des voitures. Un client ne peut louer qu'un véhicule à la
fois. On supposera pour simplifier que les clients sont identifiés par une chaîne de caractères
(leur nom par exemple).
On décide de gérer ces locations par une table (java.util.Map) qui associe les clients
représentés par leurs noms (clés) avec les voitures (valeurs) qu'ils ont louées. Un client n'est
présent dans cette table que si il loue actuellement une voiture.

74
 POO – ANNEXE

Travail demandé :
 Donner le code d'une classe CritereMarque qui est un critère satisfait par toutes les
voitures d'une marque donnée. La marque est précisée à la construction du critère.
 Donner le code d'une classe CriterePrix qui est un critère satisfait par toutes les
voitures dont le prix est inférieur à un prix fixé à la construction du critère.
 Donner le code d’une classe Voiture.
NB : Les classes CritereMarque et CriterePrix implémentent toutes les deux l’interface
Critere.
On donne ici une description des méthodes de la classe Agence :
 public void loueVoiture(String client, Voiture v) throws VoitureException : permet
au client de louer la voiture v ; un client ne peut louer qu’une seule voiture, il ne
peut louer une autre que s’il rend la première. L'exception est levée soit si la
voiture n'existe pas dans l'agence soit si elle est déjà Louée.
 public void afficheSelection(Critere c) : permet d’afficher toutes les voitures qui
satisfont un critère c donné qui peut être évidement un CriterePrix ou un CritereMarque.
 public boolean estLoueur(String client) : renvoie true si et seulement si le client est
un client qui loue actuellement une voiture.
 public boolean estLoue(Voiture v) : renvoie true si et seulement si la voiture est
actuellement louée.
 public void rendVoiture(String client) :le client rend la voiture qu'il a louée. Il ne se
passe rien si il n'avait pas loué de voiture.
 public Iterator lesVoituresLouees() qui renvoie la collection des voitures de
l'agence qui sont actuellement louées.

75
 POO – ANNEXE

Diagramme de classe : Agence de Location de Voitures

76
 POO – ANNEXE

DEVOIR SURVEILLE

Matière : Programmation Orientée Objets Groupe : II3

Enseignante : Mlle I.Sghaier  : 1H
 : Non autorisés Nb. Pages: 2

Exercice1: (10 pts: 5+5)

1 ère partie:
1. Créer une classe « employe» correspondante au schéma UML suivant. La méthode decrisToi()
affiche à l’écran le nom et le prénom de l’employé

Class employe

- String nom
- String prenom
- Double Salaire
- int NCI
-
+ Employe()
+ Employe(int n)
+ Employe(String nom,String prenom)
+ Employe(String nom,String prenom,int n, double s)
+ decrisToi()
+ String getNom()
+ String getPrenom()
+ Double getSalaire()
+ Int getNCI()

2. Créer une classe equipe qui utilise la classe Employe. La fonction main de Equipe
comprendra la création d’un tableau de quatre employés et l’affichage de leurs noms
3. Peut-on modifier la variable d’instance nom depuis l’extérieur de la classe ? et depuis
l’intérieur ?
2ème Partie :
1. Créer une classe technicien qui hérite de la classe employe. Celle-ci comprendra une
variable d’instance supplémentaire : specialite.
a. Ecrire des constructeurs : sans arguments et à 1 seul argument « String spécialité ».
Vous utiliserez les constructeurs de la classe mère.
b. Redéfinisser la méthode decrisToi(), en faisant appel à la méthode de la classe
mère. (décris toi va afficher à l’écran : nom, prénom, spécialité).

77
 POO – ANNEXE

2. En changeant les modificateurs d’accès des données membres de la classe mère, de

private vers protected peut-on accéder à ces variables de l’extérieur de la classe Employe?
Quel danger cela présente t-il en termes d’encapsulation ?
3. Expliquer le mécanisme de construction d’une classe dérivée
4. Ecrire une classe, qui teste la classe technicien.

Exercice 2: (10 pts : 6+4)

1. Ecrire une classe appelée « FonctionMath » qui contient les méthodes statiques suivantes :
- Factoriel : c’est une méthode qui permet de calculer et d’afficher le factoriel d’un
entier passé lors de l’exécution.
- RacineCarré : C’est une méthode qui permet de calculer et d’afficher la racine carrée
d’un nombre n passé lors de l’exécution
- BinaryCode : C’est une méthode qui permet de lire un entier sur la ligne de la
commande et afficher sa correspondance en binaire
- HexCode : C’est une méthode qui permet de lire un entier sur la ligne de la
commande et afficher sa correspondance en Hexadécimal.
NB : Pour les trois dernières méthodes utiliser les méthodes suivantes de la classe Integer :
toBinaryString et toHexString.
2. Ecrire une classe «TestFonctionMath» qui utilise ces fonctions mathématiques.

78
 POO – ANNEXE

Devoir à la maison

Soit la classe « Liste » caractérisée par les attributs suivants :

- tab : représente un tableau d’entiers.
- Taille : représente le nombre d’éléments de la liste.
Et les méthodes suivantes :
- Ajout_tête : Ajoute un élément à la tête de la liste.
- Ajout_queue : Ajoute un élément à la fin de la liste.
- Ajoutk : Ajoute un élément à une position donnée.
- Suppression_tête : Supprime le premier élément de la liste.
- Suppression_queue : Supprime le dernier élément de la liste.
- Suppk : Supprime l’élément se trouvant à une position donnée.
- Suppval : Supprime un élément donné d’une liste.
- Accesval : Retourne la position de 1 ère occurrence d’un élément dans une liste.
- Liste_vide : Vérifie si la liste est vide ou non.
- Liste_pleine : Vérifie si la liste est saturée ou non.
- Longueur : retourne la taille d’une liste.
- Occurrence : Retourne le nombre d’occurrence d’un élément donné.

Travail demandé
1- Ecrire en Java la classe Liste
2- Ecrire une classe Test_Liste qui permet de créer un objet de type Liste et le manipuler à travers
l’appel des méthodes de cette classe.

79
 POO – ANNEXE

DEVOIR SURVEILLE

Matière : Programmation Orientée Objets Groupe : II3

Enseignante : Mlle Imene Sghaier  : 1H
 : Non autorisés Nb. Pages : 2

Partie I
1. Ecrire en java la classe Robot obéissant au schéma UML suivant.

 orientation : est un attribut qui désigne l’orientation du Robot (1 = Nord, 2 =

Est, 3 = Sud, 4 = West)
 La méthode tourner () qui permet de tourner l’orientation du Robot.
 Les constructeurs qui permettent d’initialiser les attributs du Robot
 La méthode affiche() qui permet d’afficher l’état et l’orientation d’un Robot
2. Ecrire une classe TestRobot qui utilise cette classe ; sa fonction main comprendra la
création d’un tableau de quatre Robot, initialiser leur attributs, les afficher, les mettre en
marche (etat=true) ainsi que les orienter vers des orientations différentes chacun de
l’autre.
Partie II
Soit une classe RobotMobile qui hérite de Robot et ayant en plus les attributs entiers privés abs
et ord : ce sont les attributs qui définissent la positon de RobotMobile (abscisse et ordonné)
ainsi qu’une méthode void avancer(int x) qui permet d’avancer le Robot selon son orientation :

80
 POO – ANNEXE

 si on avance de x vers l’Est l’abscisse augmente de x,

 si on avance vers le West de x l’abscisse diminue de x,
 si on avance vers le nord de x l’ordonnée augmente de x,
 si on avance vers le Sud de x l’ordonnée diminue de x,
Et une méthode void affichePosition() qui affiche la position (coordonnées).
1. Ecrire un constructeur sans argument de la classe RobotMobile
2. Ecrire un constructeur à quatre arguments (type, code, abs et ord) de la classe RobotMobile
3. Redéfinissez la méthode affiche tout en utilisant celle de la classe mère et la méthode
affichePosition().
4. Ecrire une classe testRobotMobile qui permet de créer un RobotMobile, lui afficher les
attributs et lui appliquer la séquence d’actions suivante tout en affichant chaque fois la
position du Robot ainsi que son orientation.
a. Tourner vers l’Est
b. Avancer de 4 vers le West
c. Avancer de 6 vers le Nord
d. Avancer de 14 vers l’Est
e. Reculer de 8 vers le sud
Bon courage !

81