Poo 2mioad 14 15

Faculté des Sciences Économiques et de Gestion de Sfax
Département d'Informatique
Support de Cours
Programmation Orientée Objet
Auditoire
2ème Année Master de Recherche
Ingénierie de l’Optimisation et d’Aide à la Décision
Enseignant
Bilel GARGOURI
Année Universitaire : 2014-2015

Cours de Programmation Orientée Objet 0
Plan du Cours
Chapitre 1 : Introduction générale
Chapitre 2 : Les éléments de base du langage JAVA
Chapitre 3 : Les classes et les objets
Chapitre 4 : Les tableaux et les chaînes de caractères
Chapitre 5 : L'héritage et le polymorphisme
Chapitre 6 : Les classes abstraites et les interfaces

Chapitre 1 :
Introduction Générale
1. Les fondements de la
Programmation Orientée Objet

1.1. La programmation classique
 La programmation classique a fait progresser la qualité de la
production des logiciels. Mais, ce type de programmation
contient certaines limites.
 La programmation classique reposait sur cette équation:
Programmes = Algorithmes + Structures de données

1.2. Principe de la P.O.O.
 La programmation orientée objet consiste à représenter les

éléments du champ de l’étude du système d’information (réels ou
conceptuels) par des entités informatiques appelées "objets" en
adoptant un haut niveau d'abstraction.
 Ce type de programmation se base principalement sur les
concepts suivants : encapsulation, objet, classe et héritage.
Programme = ensemble d’objets communicants

1.2.1. Encapsulation
 L'encapsulation consiste à rassembler les données et les
traitements afférents au sein d'une structure unique (entité) en
empêchant l'accès aux données par un autre moyen que les
services proposés (une partie des traitements).
 Elle permet donc de garantir l'intégrité des données contenues

dans la structure (ou l’entité) de regroupement.

1.2.2. Objet
 C’est la structure ou l’entité qui encapsule (regroupe) des
données et des traitements cohérents.
 Les données et les traitements caractérisent l’objet, c.à.d.
représentent ses propriétés.
 Les données sont appelées les attributs de l’objet
 Les traitements sont appelés les méthodes de l’objet
 Chaque objet possède une identification unique qui est indiquée
par une ou plusieurs références
Objet = Attributs + Méthodes

1.2.3. Classe
 Une classe représente un modèle d’objets.
 Elle décrit leur structure unique (type de données et
traitements).
 Les objets sont des variables d’un tel type de classe (un objet
est une instance de sa classe) dont chacun possède ses
propres valeurs.
Exemple:

Exemple: Objets instanciés à partir de la classe Etudiant
:Etudiant1 :Etudiant2 :Etudiant3 :EtudiantN
matricule: 12 matricule: 21 matricule: 34 matricule: 41
nom : Ben Mohamed nom : Ben Salah nom : Ben Ali nom : Ben Hamida
prenom : Mohamed prenom : Salah prenom : Ali prenom : Hamida
Attributs
filiere: LFIG filiere : LFIG filiere : LFSG filiere : LFSG
niveau: 1 niveau: 2 niveau:2 niveau : 1
groupe:7 groupe:5 groupe:4 groupe:7
changerFiliere() changerFiliere () changerFiliere () changerFiliere ()

changerNiveau () changerNiveau () changerNiveau () changerNiveau () Méthodes
changerGroupe () changerGroupe () changerGroupe () changerGroupe ()
Etudiant
matricule
nom
prenom
filiere
niveau
groupe Classe Etudiant
changerFiliere ()
changerNiveau ()
changerGroupe ()
Exercice
xxxxxxxxx

1.2.4. Héritage
 L’héritage permet de définir une nouvelle classe à partir d’une
classe existante.
 La nouvelle classe comporte les même propriétés de la classe de
base, auxquelles s’ajoutent des propriétés (méthodes et/ou
attributs) spécifiques à cette nouvelle classe.
 L’héritage facilite largement la réutilisation et l’extension des
applications.
Exemple:
La classe Etudiant hérite de la classe Personne.

Exercice (suite)
xxxxxxxxx

1.3. La POO vs P. Classique
 En programmation classique les données et les
traitements sont conçues séparément.
 Lors de la conception des données, on ignore les traitements
qui vont être appliquées sur ces données.
 Les traitements peuvent manipuler différentes structures de
données.
 En POO, la démarche est la suivante :
 Identificationdes objets
 Étude des contenus (propriétés) des objets (attributs et
méthodes)
 Étude de l’interaction des objets
 Définition des classes (modèles ou types qui regroupent les
propriétés des objets similaires
Attributs
fonction Méthodes de l’objet
fonction de l’objet
fonction données
globales Attributs
Méthodee
Attributs
Méthodes de l’objet
de l’objet
Programmation classique POO

2. Le langage JAVA

2.1. Présentation générale de JAVA
 JAVA est un langage de programmation orientée objet pure,
développé par "Sun". Sa première version a été commercialisée
vers 1995.
 Il s’inspire principalement des langages de programmation
suivants : C/C++ (syntaxe très proche), SmallTalK (tout objet) et
ADA (paquetage).
 Parmi les principaux objectifs de JAVA était la proposition d’un
langage de programmation indépendant de la machine
exécutant le code.

 Pour cela, on a définit un langage machine appelé "ByteCode"
dédié à la pseudo machine nommée "Machine Virtuelle JAVA
(MVJ)". La MVJ est un programme écrit pour chaque plate-
forme particulière (Sun, Solaris, Mac, Windows NT, …) et qui
connaît le ByteCode JAVA.
JVM Sun
(1) (2)
Code Source Byte-code JVM Mac
(1) : Compilation JVM PC

(2) : Interprétation

2.2. Application et applet
Un programme JAVA est soit :
 Une application
 Une Applet : une application JAVA qui s'exécute au sein d'une
page HTML dans un navigateur
 Voir aussi une Servlet : Server-side applet
 Les servlets sont aux serveurs ce que sont les applets aux
browsers mais sans interface graphique utilisateur …

2.3. Le JDK (JAVA Development Kit)
 javac : compilateur de sources java
 java : interpréteur de byte code
 appletviewer : interpréteur d'applet
 javadoc : générateur de documentation (i.e., HTML)
 javap : désassembleur de byte code
 jdb : debugger

2.4. Exécution d’une application JAVA
 Ecriture du code source JAVA :
Le code source d'un programme JAVA est un fichier texte
(éventuellement plusieurs) écrit selon la syntaxe du langage et
possédant l’extension ".java".
 Compilation :
Les sources JAVA doivent être compilées afin de générer le
ByteCode. Les fichiers générés ont l'extension ".class".
 Interprétation :
Pour exécuter une application, on doit lancer la MVJ qui charge
dynamiquement les fichiers ".class" liés à l'application et ceux de
l'API nécessaires, puis interprète le tout.

2.5.Structure générale d’une
application JAVA
 Une application JAVA possède un point d'entrée unique qui est la
méthode (ou fonction) "main()" de prototype : public static void
main (String [] args)
 Tout fichier source doit porter le nom de la classe publique qu'il

contient avec l'extension ".java"

Exemple :
public class Bonjour
{
// déclaration des attributs
// définition des méthodes
public static void main (String [] args)
{
// déclaration des variables locales
System.out.println("Bonjour");
}
}

2.6. Exemple d’outils de développement
 Environnements de développement :
 Kawa
 JBuilder
 Visual J++
 Eclipse
 …
 Navigateurs :
 Netscape
 Internet Explorer
 Sun HotJava

2.7. Quelques références
 Livres :
 Comment programmer en JAVA, H.M. DEITEL & P.J.
DEITEL, éditions Prentice Hall, 1999
 Programmer en JAVA, Claude DELANNOY, éditions
Eyrolles, 2002
 Java 2, Benjamin AUMAILLE, éditions ENI, 1999
…
 Sites Web :
 www.javasun.com : Site officiel Java (JDK et doc.)
 www.javaworld.com : Info sur Java
 www.gamelan.com : applications, applets, packages, ...
 www.blackdown.com : Java pour linux

Chapitre 2 :
Les éléments de base du

langage JAVA
1.Identificateurs et mots réservés
1.1.Commentaires
 Trois notations sont utilisées pour l’insertion de
commentaires :
 // …. : commentaires sur ce qui reste de la ligne.
 /* …. */ : commentaires sur une ou plusieurs lignes.
 //* … */ : commentaires utilisés par Javadoc sur une ou
plusieurs lignes. Ces commentaires sont à inclure dans la
documentation générée automatiquement au format HTML par
l'utilitaire Javadoc.
Cours de POO 26
1.2.Points virgules, blocs et blancs
 Les instructions se terminent par un point virgule ";"
 Un bloc d'instructions est délimité par des accolades "{"
et "}"
 Les blancs (espaces, tabulations et sauts de lignes) sont
utilisés entre les éléments du code source
1.3.Identificateurs
 Un identificateur (d'objet, de variable, …) commence par
une lettre, un trait de soulignement "_" ou un signe dollar
"$". Les caractères qui suivent peuvent contenir des
chiffres. Les identificateurs n'ont pas de longueurs
maximales et opèrent une distinction entre majuscule et
minuscule.
Cours de POO 27
1.4.Mots réservés
abstract boolean break byte case
catch char class continue default
do double else extends false
final finally float for
implements import instanceof int interface
long native new null package
private protected public return short
static super switch synchronized this
throw throws transient true try
void volatile while const goto
Cours de POO 28
2.Types élémentaires
Les types élémentaires (de base ou encore primitifs) sont :
Type Taille Codage V. Inf. V. Sup.
byte 1 octet signé -256 255
short 2 octets signé -32768 32767
2147483647
int 4 octets signé -2147483648
long 8 octets signé -9223372036854775808 9223372036854775807
float 4 octets signé … …

double 8 octets signé … …
char 2 octets unicode
boolean 1 bit false/true false true
Cours de POO 29
 Il existe un vrai type booléen qui ne peut prendre que
deux valeurs : true ou false. Il n'existe pas de
conversion automatique du type boolean vers un autre
type Exemple: int i=5; if (i) est une instruction
incorrecte
 Les caractères ne sont pas codés en ASCII, mais en
Unicode. Le codage Unicode est une extension du
codage ASCII : les 128 premiers caractères Unicode
sont les mêmes que ceux de l'ASCII, et au delà de 128,
de nouveaux caractères sont définis
 String n'est pas un type de base mais une classe
Cours de POO 30
3.Variables et constantes
3.1.Variables
La déclaration des variables et leur affectation
s'effectue de façon similaire au langage C.
Exemples :
byte i=5;
int x=320;
long l = 36600040;
float f = 253.56;
double d=23.9 e31;
char c='a';
boolean b= true;
Cours de POO 31
3.2.Constantes
 Une constante est déclarée avec le modificateur
"final". Il est obligatoire de l'initialiser au moment de
la déclaration. Les identificateurs des constantes
sont (par convention) en majuscule.
Exemple : final double PI = 3.141592;
Cours de POO 32
4.Les expressions
4.1.Rappel
 Une constante ou une variable forme ce qu'on
appelle une expression. Les expressions peuvent
être combinées entre elles par des opérateurs et
former ainsi des expressions plus complexes.
Cours de POO 33
4.2.Les principaux opérateurs
Type des opérateurs Opérateurs Types des opérandes
binaire +, -, *, /, % Entiers et réels
Arithmétiques unaire -, --, ++
étendus +=, -=, *=, /=
Logiques !, &&, || Booléens
De comparaison (le ==, !=, <, <=, >, >= Tout type (y compris
résultat est booléen) les références d'objets)
Cours de POO 34
4.3.Conversion de types
 Il existe quatre conversions de types :
 Conversion explicite (casting)
 Conversion implicite lors d'une affectation
 Conversion implicite lors d'une promotion arithmétique. C'est
le cas où les opérandes d'un opérateur ne sont pas du même
type. Le choix de l'opérande à convertir se fait du type le plus
restreint vers le type le plus large.
 Conversion implicite lors d'un passage de paramètres
 Les conversions implicites légales en JAVA sont :

 Byteshortintlongfloatdouble
 Charintlongfloatdouble
Cours de POO 35
 Les conversions pouvant provoquer une perte de valeur ne sont
pas autorisées de manière implicite. Elles doivent être
demandées explicitement (exemple : de float vers int).
Exemples de conversion :
int i,j;
short s = 2;
float f = 1.5;
i = (int) f; // conversion explicite obligatoire avec perte
i = s; // conversion implicite
f = i / 2.0; //conversion par promotion arithmétique
// soit la méthode : int meth(int arg)
j=objet.meth(s); // conversion lors d'un passage de
//paramètres
Cours de POO 36
5.Les structures de contrôle
 Utilisation des même structures de contrôle que le langage C tout
en gardant la même syntaxe : if, ? :, switch, while, do while, for.
 Utilisation des blocs labellisés
UN: while(...) {
DEUX: for(...) {
TROIS: while(...) {
if (...) continue DEUX; // Boucle for
if (...) break UN; // Quitte la 1ère boucle while
continue; // 2ème boucle while
…
} } }
Cours de POO 37
5.1.La structure if
class IfApp {
public static void main(String args[ ]) {
int c = 0 ;
if ( c == 1 )
System.out.println( " Jamais imprimé " ) ;
else
System.out.println( " Ceci sera imprimé" ) ;
} }
Remarque : L'évaluation de l'expression de la condition
est obligatoirement de type booléen.
Cours de POO 38
5.2.La structure switch
char c = (char) System.in.read( );
switch ( c )
{ case 'a' : case 'A' :
System.out.println( " A " ) ;
break ;
case 'b' : case 'B' :
System.out.println( " B " ) ;
break ;
default :
System.out.println( " Erreur " ) ;
break ;
}
Cours de POO 39
5.3.La structure while
class WhileApp
{ public static void main(String args[ ])
{ int c ;
do {
System.out.println("Entrez un nombre positif <= 5") ;
c = Clavier.lireInt( ) ;
} while ( c <= 0 || c > 5 );
while ( c > 0 )
System.out.println( c-- );
}
}
Cours de POO 40
5.4.La structure for
class ForApp
{
public static void main(String args[ ])
{
int i ;
for ( i=0 ; i<=5 ; i++ )
System.out.println( i ) ;
for ( int j=0 ; j<=5 ; j++ )
System.out.println( j ) ;
j = 2 ; // ERREUR : j est local à la boucle for
}
}
Cours de POO 41
5.Les tableaux
 Déclaration :
int[ ] T; // équivalent à : int T[ ];
float cube [ ][ ][ ];
 Création et initialisation :
int[ ] tab = {1, 2, 3, 5, 7, 7+4};
T = new int[42];
cube = new float[256][256][256];
T[0] = 3;
Cours de POO 42
 Pour les tableaux dont le type de données est primitif,
chaque élément est initialisé par la valeur nulle du type
 Pour les tableaux dont les éléments sont des objets
chaque élément est initialisé à null
 Les indices des tableaux commencent par 0
 Utilisation des tableaux
int l = T.length; // l = 42
int e = T[50];
//Lève l’exception //ArrayIndexOutOfBoundsException
Cours de POO 43
Chapitre 3 :
Les classes et les objets

1. Définition des classes
 On rappelle que la classe est un modèle de définition pour les
objets ayant les mêmes propriétés
 Elle est considérée en programmation comme un type défini par
le concepteur
 Il existe des contrôles d'utilisation d'une classe

 La classe définit les contrôles (ou restrictions) d'accès
aux propriétés (attributs et méthodes) de ses objets.
 L'objet peut se comporter comme une boîte noire (le contenu est
masqué par des contrôles d'accès). Dans ce cas, quelques
méthodes doivent assurer son intégration dans le système. Ces
méthodes représentent une interface de service
 Le contrôle d'utilisation d'une classe et celui d'accès aux
membres d'une classe sont deux concepts différents

2. Organisation des classes en packages
 Chaque définition de classe fait parti d’un package
 Un package est considéré comme une bibliothèque de classes. Il
permet de regrouper un certain nombre de classes ayant,
généralement, des rôles proches
 Les packages sont organisés hiérarchiquement à la manière des
répertoires : on peut définir des
sous-packages, des sous-sous-packages…
 On peut créer des packages, ajouter des classes dans un
package existant ou utiliser des définitions de classes à partir de
leurs packages
 Le répertoire contenant vos classes simule un package

3. La syntaxe de déclaration d’une
classe
En JAVA, la syntaxe de déclaration d'une classe est la suivante :
[public] [abstract/final] class NomClasse
[extends NomSuperClasse]
[implements NomInterface1, Interface2, …,
InterfaceN]
{
// déclaration des attributs
// déclaration des méthodes
}

 public : un modificateur d'accès précisant la possibilité d'utilisation
de la classe :
 public donne la possibilité d'utiliser la classe à toutes les autres
classes
 par défaut, le modificateur est private : l'utilisation de la classe
est réservée aux classes du même package
 abstract et final : deux qualificateurs en relation avec le concept
d'héritage (voir chapitre 5)
 extends : annonce l'héritage de la classe NomSuperClasse (voir
chapitre 5)
 implements : annonce l'implémentation d'une ou plusieurs
interfaces par la classe (voir chapitre 6)
 Il ne peut y avoir qu'une seule classe publique par fichier

3.1.Déclaration des attributs
En JAVA, la syntaxe de déclaration d'un attribut est la suivante :

[private/public/protected] [static] [volatile] [final]
type_attribut nom_attribut [= valeur];

 private, public et protected : des modificateurs d'accès à l'attribut
à partir d'autres classes :
 private indique que l'accès est réservé aux méthodes de la
même classe
 public donne la possibilité d'accès à toutes les méthodes des
autres classes
 protected limite l'accès aux méthodes de la même classe, des
classes dérivées et des classes du même package
 par défaut, l’accès est dit friendly, il correspond à un accès
privé au package (et non privé à la classe)
 static : précise le fait qu'il y aura une seule copie de cet attribut
qui est commune à tout objet crée à partir de la classe en
question (il s'agit d'un attribut de classe)
 final : indique que l'attribut est une constante

3.2.Déclaration des méthodes
En JAVA, la syntaxe de déclaration d'une méthode est la

suivante :
[private/public/protected]
[native] [transient][synchronized]
[static][final/abstract] type_de_retour nom_méthode
([t_paramètre1 paramètre1, …, t_paramètreN paramètreN] )
{
// déclaration des variables locales;
[type_de_retour var_résultat;]
// instructions de la méthode
[return var_résultat;]
}
 private, public et protected : des modificateurs d'accès
autorisant l'appel aux méthodes de la classe (voir déclaration
des attributs)
 static : précise que l'exécution de la méthode n'est pas liée
aux instances de la classe (il s'agit d'une méthode de classe)
 abstract : la méthode ne comporte pas de code. Par
conséquent toute la classe devient abstraite (voir chapitre 5)
 final : la méthode ne pourra pas être redéfinie dans une
classe dérivée (voir chapitre 5)
 Le passage des paramètres est par valeur pour les
arguments de type primitif (de base) et par référence pour
les arguments de type classe (référence d'objet) et les
tableaux

 Le nom d'une méthode commence par une minuscule
 Le nom d'une variable locale est en minuscule (si non final)
 Une méthode peut être surchargée : définition, au sein d'une

même classe, de plusieurs méthodes portant le même nom
mais qui sont différents au niveau des paramètres (type,
ordre et nombre d'arguments)

Exemple :
class Etudiant // par défaut elle est privée au package
{
private int matricule;
private String nom;
private String prenom;
public String filiere; // on a choisi public pour des exemples futures
private int niveau;
private int groupe;
public void changerFiliere(String f)
{filiere = f;}
public void changerNiveau (int n)
{niveau = n;}
public void changerGroupe (int g)
{groupe = g;}
} Cours de Programmation Orientée Objet 55
Remarque : Dans nos futures exemples et à défaut
d’une indication dans l’énoncé, on
déclarera les attributs privés et les
méthodes publiques.

4.L’instanciation des objets
4.1. Référence d'un objet
 Les références d'objets sont des variables de type classe qui
permettent de désigner des objets à la manière des pointeurs
en C (sans manipulation directe d'adresse).
 La référence qui ne pointe sur aucun objet contient la valeur
"null".
 Il est possible d'avoir à un instant t plusieurs références pour
désigner un même objet.
 Les opérateurs possibles sur les références d'objets sont : new,
=, ==, != (si deux références désignent un même objet) et
instanceof.

4.2.Instanciation
 La création d'un objet se fait à l'aide de l'opérateur new qui se
charge de :
 Allouer l'espace mémoire nécessaire pour stocker les

attributs de l'objet en cours de construction
 Appeler le constructeur de l'objet adéquat pour initialiser les

attributs. Le choix du constructeur se fait en fonction des
paramètres passés (mêmes règles que pour la surcharge
des méthodes normales)
 Retourner une référence sur l'objet créé

 Un objet qui n'est référencé par aucune référence est détruit par
le ramasse miettes (Garbage Collector) qui s'exécute en
permanence. Cependant, on peut demander explicitement le
service de ce processus par : « System.gc() »
Exemple :
public class TestEtudiant
{
public static void main(String [] args)
{Etudiant e1;
e1 = new Etudiant();
}
}

5.La notion de Constructeur
 Le constructeur d'une classe est une méthode appelée une
seule fois par objet et ce au moment de sa création. Le
constructeur porte le même nom que celui de la classe
 Le rôle du constructeur est d'initialiser les attributs de l'objet
 En l’absence d’un constructeur défini par le programmeur,
JAVA offre un constructeur non paramétré qui initialise les
attributs de l'objet crée par les nulls correspondant à leurs
types (0 pour int, null pour les références aux objets, …)
 Le programmeur peut définir ses propres constructeurs (voir
surcharge des méthodes) pour initialiser certains attributs
 Le constructeur est toujours publique et ne possède pas de
type (même pas void).

Exemple:
class Etudiant
{ private int matricule;
private String nom;
public String filiere; // on a choisi public pour des exemples futures
private int niveau;
private int groupe;
public Etudiant()
{matricule = 12; nom= "Mohamed"; prenom= "Ben Mohamed";
filiere = "LFIG"; niveau=1; groupe =1; }
public Etudiant(int m)
{matricule = m; nom= "Mohamed"; prenom= "Ben Mohamed";
filiere = "LFIG"; niveau=1; groupe =1;}
public Etudiant(int m, String n,String p)
{matricule = m; nom= n; prenom=p; filiere = "LFIG"; niveau=1;
groupe =1;}
public Etudiant(int m,String n, String p, String f, int niv )
{matricule = m; nom= n; prenom=p; filiere = f; niveau= niv; groupe =1;}
public Etudiant(int m,String n, String p, String f, int niv , int g)
{matricule = m; nom= n; prenom=p; filiere = f; niveau= niv; groupe =g;}
{filiere = f;}
{niveau = n;}
{groupe = g;}
}

6.La notion de Destructeur
 Le destructeur est une méthode qui exécute certaines tâches
avant la destruction d'un objet. Il est aussi appelé "finaliseur".
 L'exécution du destructeur se fait automatiquement par le
ramasse miettes.
 En JAVA, le destructeur est optionnel. S'il est décrit, il est
unique.
 En JAVA, le destructeur s'appelle finalize. Il est de type void et
ne reçoit pas de paramètres. Son modificateur d'accès est
protected. Son prototype est alors le suivant :
protected void finalize()

Exemple:
class Etudiant
private String nom, prenom; // même modificateur d’accès et même type
public String filiere;
private int niveau;
private int groupe;
private static int nbEtudiant = 0;
public Etudiant()
{matricule = 12; nom= "Mohamed"; prenom= "Ben Mohamed";
filiere = "LFIG"; niveau=1; groupe =1; nbEtudiant ++; }
public Etudiant(int m)
{matricule = m; nom= "Mohamed"; prenom= "Ben Mohamed";
filiere = "LFIG"; niveau=1; groupe =1; nbEtudiant ++; }
public Etudiant(int m, String n,String p)
{matricule = m; nom= n; prenom=p; filiere = "LFIG"; niveau=1; groupe =1;
nbEtudiant ++;}
public Etudiant(int m,String n, String p, String f, int niv )
{matricule = m; nom= n; prenom=p; filiere = f; niveau= niv; groupe =1;
nbEtudiant ++;}
public Etudiant(int m,String n, String p, String f, int niv , int g)
{matricule = m; nom= n; prenom=p; filiere = f; niveau= niv; groupe =g;
nbEtudiant ++;}
{filiere = f;}
{niveau = n;}
{groupe = g;}
protected void finalize()
{ nbEtudiant--; }
}

7. Manipulation d’un objet
7.1. Aperçu sur les droits d’accès aux
membres d’un objet
 La possibilité de créer un objet dépend des restrictions
d'utilisation de la classe à instancier
 La manipulation des membres d'un objet crée suit les

restrictions d'accès de ces membres précisées dans la classe
 On ne peut accéder (consulter ou modifier) à un attribut de

l’extérieur de la classe là où il a été défini que si on est autorisé
à le faire
 On ne peut invoquer (lancer l’exécution ou encore
appeler) une méthode de l’extérieur de la classe là où
elle a été définie que si on est autorisé à le faire
 On ne s’intéresse aux droits d’accès qu’au niveau de

la définition des classes

7.2.Manipulation des attributs
 On distingue deux types d’attributs :
 Attribut d’objet : déclaré sans le mot réservé static. Une

copie de cet attribut existe dans chaque objet. L’existence
d’un tel attribut dépend de l’existence des instances de la
classe
 Attribut de classe : déclaré avec le mot réservé static.

L’existence de cet attribut ne dépend pas des instances de
la classe. S’il y a eu une instanciation, une seule copie de
cet attribut est partagée par toutes les instances.

 Les attributs d’objet sont désignés selon la syntaxe suivante:
« nomObjet.nomAttribut »
 Les attributs de classe sont désignés selon la syntaxe

suivante: « NomClasse.nomAttribut »
 Au sein de la classe propriétaire, on peut désigner un attribut

(static ou non) uniquement par son nom.

7.3.Invocation des méthodes
 On distingue deux types de méthodes :
 Méthode d’objet : déclarée sans le mot réservé static. Une

copie de cette méthode est associée à chaque objet.
L’exécution d’une telle méthode se fait toujours pour un objet
déterminé.
 Méthode de classe : déclarée avec le mot réservé static.

L’exécution d’une telle méthode ne dépend pas des objets
de la classe.

 Les méthodes d’objets sont désignées selon la syntaxe
suivante: "nomObjet.nomMéthode()".
 Les méthodes de classe sont désignées selon la syntaxe

suivante : "NomClasse.nomMéthode()".
 Au sein de la classe propriétaire, on peut désigner une méthode

(statique ou non) uniquement par son nom.
Remarque : Un attribut d’objet (non static) ne peut pas être

manipulé directement par une méthode de classe (static).

Exemple :

{
{ Etudiant e1;
e1 = new Etudiant();
e1.changerGroupe(5);
e1.filiere = "LAG";
// accepté car l’attribut filiere est public
// e1.groupe=5;
//n'est pas accepté car l’attribut groupe est private
}
}
8. Référence sur l'objet courant this
 Le mot-clé this représente une référence sur l'objet courant,
c.à.d., celui qui possède la méthode qui est en train de
s'exécuter
 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.
 Lorsqu’on ne connaît pas encore une référence pour l’objet
en cours.

Exemple :
class Etudiant
public String nom, prenom;
…
public Etudiant(int matricule, String nom, String prenom)
{this.matricule = matricule;
this.nom = nom;
this.prenom = prenom;
filiere = "LFIG"; niveau=1; groupe =1; }
…
}

9. Détermination de la nature d'un objet
 L'opérateur instanceof permet de tester si l'objet référencé est

une instance d'une classe donnée (ou d'une de ses sous-
classes voir chapitre 5).
Exemple :
…
if (e1 instanceof Etudiant)
// résultat vrai ou faux
…

10. Un objet comme attribut dans un
autre objet
 Les objets peuvent être utilisés comme attributs dans d'autres
objets selon les restrictions d'utilisation
 Si l'objet jouant le rôle d'attribut est déjà crée (utilisé ailleurs), il
suffit d'effectuer une affectation entre références pour réaliser
le lien à travers un passage de paramètre (au niveau du
constructeur ou d'une autre méthode)
 Si l'utilisation de l'objet attribut est réservée à l'objet qui
l'intègre, l'objet attribut doit être crée comme tout autre objet
par l'opérateur new au niveau du constructeur de la classe qui
l'utilise ou même dans l'instruction d'appel du constructeur (ou
d'une autre méthode).

Exemple :
class Stage
{
private String sujet;
private String nom_entreprise;
private String duree;
public Stage(String s, String e, String d)
{sujet = s; nom_entreprise = e; duree= d;}
public void changerSujet (String s)
{sujet = s;}
public void afficher ()
{System.out.println ("le stage est de sujet : " + sujet +
"au sein de l’entreprise : " + nom_entreprise+ " pour une
durée de : " + duree );
}
}
class Etudiant
{
private Stage stage;
…
public Etudiant(int m, String n, String p, String f, int niv, int g)
{matricule = m; nom= n; prenom= p; filiere = f; niveau=niv; groupe =g;
stage = new Stage ("Sujet 1", "STEG", "1 mois");} // 1er cas
public Etudiant(int m, String n, String p, String f, int niv, int g, Stage s)
{matricule = m; nom= n; prenom= p; filiere = f; niveau=niv; groupe =g;
stage = s;} // 2ème cas
…
public void changerStage (Stage s)
{ stage = s;}
public void changerSujetStage (String suj)
{ stage.changerSujet (suj);} // l’attribut sujet est privée à Stage
}

public class Exemple // Hypothèse : 3 classes dans un même package
{public static void main(String [] arg)
{ Etudiant e1, e2, e3;
Stage st1;
st1 = new Stage ("Sujet1", " STEG" , "1 mois");
e1 = new Etudiant (21, "Ben Mohamed", "Mohamed", "LFE", 2, 4);
// 1er constructeur
e2 = new Etudiant (101, "Ben Ali", "Ali", "LFIG", 1, 5, st1);
// 2ème constructeur
e3 = new Etudiant (103, "Ben Salah", "Salah", "LFIG", 1, 6,
new Stage ("Sujet2", " PTT" , "15 jours"));
// 2ème constructeur
e3.changerStage(st1); // l’ancien Stage sera éliminé
e3.changerSujetStage("Sujet 3");
}
}
11. Quelques conventions utiles
 Les prototypes des méthodes qui modifient ou retournent les

valeurs des attributs suivent une convention particulière :
 Le prototype d’une méthode qui retourne la valeur d’un
attribut est : public type_attribut getAttribut()
 Le prototype d’une méthode qui modifie la valeur d’un
attribut est : public void setAttribut(type_attribut valeur)
 Ces méthodes sont utiles surtout quand l’attribut en question
n’est pas public, c’est pour cela que le modificateur d’accès
à ces méthodes est public

Exemple :
class Etudiant
{
…
public int getMatricule()
{return matricule;}
public void setMatricule(int m)
{matricule = m;}
}
class Exemple
{
public static void main (String arg[])
{
Etudiant e = new Etudiant();
e.setMatricule(99);
System.out.println(matricule =+e.getMatricule());
}
}
 Généralement, on décrit dans chaque classe une
méthode ayant le prototype suivant :
public String toString()
 L’objectif de cette méthode est de retourner une description

(totale ou partielle) sous forme d’une chaîne de caractères
d’un objet
 L’utilité de toString() s’accroît lorsque les attributs ne sont
pas publics
 La description retournée peut être utilisée comme paramètre
à une autre méthode, stockée dans une certaine structure tel
qu’un tableau ou affichée
 En réalité, la description d’une méthode toString()
correspond à une redéfinition d’une autre version de cette
méthode qui se trouve par défaut dans chaque classe (voir
plus de détails avec l’héritage dans le chapitre 5)

Exemple :
class Etudiant
{
…
public String filiere;
…
{
String s; //on peut s’en passer d’utiliser s
s=Le matricule de l’étudiant est :+matricule+ Sa filière est :
+ filiere;
return s;
}
…
}
class Exemple
{
public static void main(String [] arg)
{
String s ;
Etudiant e = new Etudiant ();
e.setMatricule(114);
e.setFiliere(LFIG);
s=e.toString();
System.out.println(s);
//on peut mettre System.out.println(e.toString());
//on verra par la suite qu’on pourra mettre
//System.out.println(e);
}
}

Chapitre 4 :
Les tableaux et les chaînes de

caractères
1. Les tableaux
1.1. Déclaration
1.2. Création et initialisation

 Pour les tableaux dont le type de données est primitif, chaque
élément du tableau est initialisé selon son type : 0 pour les
numériques, false pour les booléens, null pour les chaînes de
caractères, ….
 Pour les tableaux dont les éléments sont des objets chaque
élément est initialisé à null
 Les indices des tableaux commencent par 0

1.3. Accès aux éléments:
 Une fois le tableau créé, on accède à ses éléments en utilisant

la même notation qu'en C : tab[i]
où i est une expression de type entier
 Le schéma suivant est la bonne manière de représenter l'accès
à tab[i] :

1.4. Taille effective d'un tableau
 L'expression unTableau.length permet de connaître le nombre

d'éléments d'un tableau. Cela est bien utile pour écrire des
traitements de tableaux dont la taille est inaccessible lors de la
compilation

1.5. Contrôle de l'indice
 Lors de l'accès à un élément d'un tableau, Java contrôle
toujours la validité de l'indice. Autrement dit, lors de l'évaluation
d'une expression comme tab[i] les deux erreurs possibles les
plus fréquentes sont détectées et déclenchent une exception :

- NullPointerException, pour indiquer que tab = null,
c'est-à-dire que la variable tab n'est pas une référence valide
(en clair, le plus souvent : la variable tab a bien été déclarée,
mais le tableau correspondant n'a pas encore été créé),
- ArrayIndexOutOfBoundsException, pour indiquer que la
condition 0 <= i < tab.length n'est pas satisfaite.

1.6. Quelques compléments sur les tableaux :
 Un tableau est considéré comme un objet

 Les tableaux sont toujours manipulés par référence
 La déclaration d'un tableau ne fait qu'associer son
identificateur à une variable de nature référence initialisée à
null

 La taille d'un tableau est indiquée lors de sa création par la
primitive new
 Un tableau peut être construit sur la base d'un type primitif ou
d'un type construit (classe ou tableau)
 Un tableau qui n'est plus référencé est éliminé par le ramasse

miettes

1.7. Argument et résultat d'une méthode
 Un tableau peut être passé comme argument à une méthode. Il
s'agit plutôt du passage de sa référence
 Pour passer une variable de type primitif par référence à une

méthode, on la déclare comme un tableau d'un seul élément
 Une méthode peut retourner un tableau. On restitue alors une

référence sur le tableau résultat

1.8. Les opérateurs appliqués sur les
tableaux
 On peut appliquer les opérateurs : =, ==, et !=. La manipulation
concerne plutôt les références des tableaux

1.9. Les tableaux à plusieurs dimensions
 JAVA permet de gérer des tableaux à plusieurs dimensions. Un
tableau à plusieurs dimensions est géré comme un tableau de
tableaux (de tableaux …)
int mat [][]; // mat désigne un tableau de int à deux indices

int [] mat[]; // mat désigne un tableau de int à deux indices
int [][] mat;// mat désigne un tableau de int à deux indices
 Ainsi, un tableau à deux indices dont les éléments sont,

par exemple, des int est réalisé en Java comme un tableau à un
indice dont les éléments sont des [références sur des] tableaux à
un indice dont les éléments sont des int.

Exemple :
int [][] t=new int[5][];
for(int i=0; i<t.length;i++)
t[i]=new int[5 - i];
for(int i=0; i<t.length;i++)
for(int j=0; j<t[i].length;j++)
t[i][j] = i+j;
[0] [1] [2] [3] [4]

t[0] 0 1 2 3 4
t[1] 1 2 3 4
t[2] 2 3 4
t[3] 3 4
t[4] 4
1.10. Les tableaux d'objets
 Un tableau déclaré à partir d'une classe, contient des références
à des objets de la classe en question. Chaque élément du
tableau représente une référence à un objet.

Exemple :
{
{
Etudiant e;
Etudiant t[] = new Etudiant [2];
// déclaration d'un tableau de deux éléments
t[0] = new Etudiant (); // nouvel objet
t[0].setFiliere("LFIG");
boolean b= t[0] instanceof Etudiant;
t[1] =t[0]; // deux références pour un même objet
e=t[1]; // on dispose finalement d'un seul objet
}
}

2. Les chaînes de caractères
2.1. Les tableaux de char

 Une chaîne de caractères peut être contenue dans un tableau
de char. Chaque caractère est placé dans une case du tableau
sans utiliser de caractères spéciaux comme le '\0'
 Cependant, cette solution n'offre pas la possibilité d'utiliser des
services de manipulation standard de chaînes. Elle est, donc,
rarement utilisée

Exemple:
class TableauChar
{
public static void main(String[] arg)
{
char[] tableau;
tableau = new char[4];
tableau[0] = 'J';
tableau[1] = 'A';
tableau[2] = 'V';
tableau[3] = 'A';
System.out.println(tableau); //affiche : JAVA
}
}

2.2. La classe String
 JAVA offre dans sa librairie (API) une classe appropriée aux
chaînes de caractères nommée String, très riche en
fonctionnalités
 La classe String offre des objets constants de chaînes. Cela
signifie que le contenu de l'objet String ne peut pas être
modifié. Cependant, la même référence de l'objet peut être
utilisée pour désigner d'autres objets String
 La classe String est très utilisée dans les applications JAVA,
pour des raisons de facilité, on peut s'en passer de l'utilisation
de l'opérateur new pour instancier un objet String
 Les opérateurs + et += sont utilisés pour réaliser la
concaténation des chaînes

Exemple :
class TestString
{
{
String ch1,ch2;
ch1="Programmation";
ch2=ch1;
System.out.println("ch1: " +ch1);//Programmation
ch1+=" en JAVA"; //Création d'un nouvel objet
System.out.println("ch1: " +ch1);//Programmation en JAVA
Ch1=Clavier.lireString();//encore un nouvel objet
}
}
 Parmi les fonctionnalités offertes par la classe String :
 char charAt(int i) : retourne le caractère dans la position i ( la

première position est d'indice 0)
 int compareTo(String anotherString) : retourne 0 si les deux

chaînes comparées sont égales, une valeur inférieure à 0 si la
chaîne comparée est inférieure à la chaîne en argument et une
valeur supérieure à 0 si la chaîne comparée est supérieure à la
chaîne en argument
 boolean equals(Object anotherObject) : retourne true si

anotherObject est un String qui contient la même séquence de
caractères
 boolean equalsIgnoreCase(String anotherString) : même rôle

que equals mais sans tenir compte de la différence entre
majuscule et minuscule
 int indexOf(char ch) : retourne l'indice de la première
occurrence de ch (considéré comme un caractère) dans la
chaîne (ou –1)
 intindexOf(String str) : retourne l'indice du premier caractère

de la première occurrence de str dans la chaîne (ou –1)
 String concat(String str) : retourne un nouvel objet String

contenant la chaîne en argument concaténée à la fin de la
chaîne traitée. Si la longueur de str est nulle, on garde l'objet
de départ comme résultat
 int length() : retourne la longueur de la chaîne

2.3. La classe StringBuffer
 La classe StringBuffer offre des objets chaînes modifiables, càd

des chaînes dont on peut changer des morceaux, dont on peut
changer la taille, …
 Contrairement à la classe String, il n'est pas possible d'utiliser

l'opérateur + (et +=) avec les objets de cette classe
 Lorsqu'un objet du type StringBuffer est construit, un tableau de

caractères est alloué dans l'objet. Sa taille initiale est de 16,
mais si l'on ajoute plus de 16 caractères dans l'objet, un
nouveau tableau, plus grand est alloué (les caractères sont
recopiés de l'ancien tableau vers le nouveau et l'ancien tableau
est détruit)

 Parmi les fonctionnalités offertes par la classe StringBuffer :
 int length() : retourne la longueur de la chaîne
 int capacity() : retourne la taille du tableau associé
 StringBuffer append(char c) : ajoute le caractère c à la fin de
la chaîne
 StringBuffer append(String str) : ajoute le contenu de l'objet
str à la fin de la chaîne
 StringBuffer append(char str[]) : ajoute le contenu du tableau
str à la fin de la chaîne
 StringBuffer insert(int i, char c) : insère le caractère c à la
position i de la chaîne
 StringBuffer insert(int i, String str) : insère le contenu de
l'objet str à la position i de la chaîne
 StringBuffer reverse() : inverse la chaîne
Chapitre 5 :
L'héritage et le polymorphisme
1. Le concept de l’héritage
1.1. Principe de base
 Le concept de l'héritage spécifie une relation de

spécialisation/généralisation entre les classes (Document :
livre, revu, …/Personne : étudiant, employé…)
 Lorsqu'une classe D hérite d'une classe B :

 D possède toutes les caractéristiques de B et aussi,
d'autres caractéristiques qui sont spécifiques à D
 D est une spécialisation de B (un cas particulier)

B est une généralisation de D (cas général)
 D est appelée classe dérivée (fille)
 B est appelée classe de base (mère ou super-classe)
 Tout objet instancié de D est considéré, aussi, comme un
objet de type B
 Un objet instancié de B n'est pas forcément un objet de type
D
 L'héritage est étudié par niveau (on ne s'intéresse pas si la
classe de base a été, elle même, dérivée d'une autre classe)
 Une classe peut hériter de plusieurs classes: héritage multiple
(Exemple : Etudiant et Employé en même temps)
 Une classe de base peut être héritée par plusieurs classes
(Exemple : Document)

1.2. Intérêts
 L'héritage minimise l'écriture du code en regroupant les

caractéristiques communes entre classes au sein d’une seule (la
classe de base) sans duplication.
 Localisation facile, en un point unique, des sections de code.
 La rectification du code se fait dans des endroits uniques grâce à
la non redondance de description
 L’extension ou l’ajout de nouvelles classes est favorisée surtout
en cas d’une hiérarchie de classes bien conçue
 Définition des informations et des comportements aux niveaux
opportuns.
 Rapprochement de la modélisation des systèmes d’informations
aux cas réels.
2. L’héritage en JAVA
 L'héritage est représenté par la notion d'extension (extends)
 Une classe D peut être définie comme étant une extension

d'une autre classe B
 Une référence d'objet déclarée de type B peut référencer un

objet de type D (l'inverse est faux)
 Pas d'héritage multiple (possible avec les interfaces)

 Toutes les classes héritent de la classe Object (même sans
l'indiquer) définie dans le package java.lang de l'API de JAVA.
Object comporte uniquement des méthodes
 Tout objet est considéré de type Object

 La déclaration de l'héritage suit la syntaxe suivante:
[modificateur d'accès] class ClasseDérivée extends ClasseBase

Exemple :
class Personne
{
private String nom;
private String adresse;
public void afficher()
{
System.out.println ("le nom est : "+ nom+ “\n son prénom est: “+
prenom+“\n son adresse est:“+adresse);
}
public void changerAdresse (String adr)
{adresse = adr;}
}

Exemple :
class Etudiant extends Personne

{
private String filiere;
private int niveau;
public void nouvNiveau(int n)
{niveau = n;}
public void changerFiliere (String f)
{filiere = f;}
}

2.1. Définition du constructeur de la classe
dérivée
 Le constructeur de la classe de base se charge d'initialiser les
attributs hérités, il est désigné par super()
 Le constructeur de la classe de base est identifié selon les
paramètres de super()
 L'appel du constructeur de la classe de base doit être la
première instruction dans le constructeur de la classe dérivée
 A défaut d'appel de super(), JAVA appelle implicitement le
constructeur sans paramètres de la classe de base. Il s'agit du
constructeur par défaut de la classe de base si le programmeur
n'a pas défini de constructeur, ou du constructeur sans
paramètres défini par le programmeur (dans ce cas obligatoire)
Exemple :
class Personne
{
public Personne (String n, String p, String adr)
{ nom = n, prenom = p; adresse=adr;}
…
}
{
public Etudiant (String n, String p, String adr, int m, String f, int niv)
{super(n,p,adr);
matricule = m;
filiere=f;
niveau=niv;
}
…
2.2. Accès aux membres hérités
(au sein de la classe dérivée)
 Si les membres (attributs et méthodes) hérités sont déclarés

avec le modificateur private dans la classe de Base, la classe
Dérivée n'a pas le droit de les manipuler directement malgré
qu'ils font parti de sa description
 Le modificateur protected (réservé aux membres), s'il est utilisé

dans la classe de Base, autorise la classe Dérivée à accéder
directement à ses membres hérités (accès réservés à toutes les
classes dérivées à tous les niveaux, mais aussi aux classes du
même package)
 Un membre hérité est désigné par super.membre (si l'accès

est autorisé)

 En dehors de la définition de la classe Dérivée, tous les membres
de cette classe sont vus comme des membres non hérités
Exemple :
class Personne
{
protected String nom;
private String adresse;
…
public String getPrenom()
{return prenom;}
public String getAdresse()
{return adresse;}
…
} 131
Cours de Programmation Orientée Objet
{
…
{
return ("Le nom de l’étudiant est:"+super.nom+
"\n son prénom est:"+super.getPrenom()+
"\n son adresse est :"+super.getAdresse()+
"\n Sa matricule est:"+matricule+ " \n de la
filière"+filiere+"et de niveau:"+niveau);
}
…
}

3. Redéfinition des méthodes héritées
 Une méthode héritée peut être redéfinie si sa version initiale
n'est pas satisfaisante pour la classe dérivée
 La redéfinition consiste à conserver l'entête de la méthode et à
proposer un code différent
 Lors de la redéfinition d'une méthode, l'appel de l'ancienne
version (celle de la classe de base) est possible par
super.nom_méthode(), et ce dans l'endroit du nouveau code
que le programmeur juge adéquat
 super n’est obligatoire que dans le code de la redéfinition pour
appeler la méthode de la classe de base
 Si une méthode héritée est redéfinie, c'est uniquement la
nouvelle version qui fait parti de la description de la classe
dérivée
 Si la méthode définie au niveau de la classe dérivée est de
type différent, ou de paramètres différents, alors il s’agit d’une
nouvelle méthode qui s’ajoute à celle héritée de la classe de
base
 En cas d’une conservation totale de l’entête par la méthode de

la classe dérivée :
 Le modificateur d’accès peut être changé selon la règle
suivante : du plus restreint au plus large.
 Une méthode d’objet ne peut pas être redéfinie par une
méthode de classe

Exemple :
{
…
{super.afficher();
System.out.println("\n sa matricule est:"+matricule+ " \n de la
filière"+filiere+"et de niveau:"+niveau);
}
public String toString() //Redéfinition de la méthode de Object
{return ("Le nom de l’étudiant est:"+super.nom+
"\n son prénom est:"+super.getPrenom()+
"\n son adresse est :"+super.getAdresse()+
"\n sa matricule est:"+matricule+ " \n de la filière"+filiere+"et
de niveau:"+niveau);
}
4. Redéclaration des attributs
 Il est possible de déclarer deux attributs portant le même nom
dans la classe de Base et dans la classe Dérivée. Les types et
les modificateurs d’accès peuvent aussi varier.
 Pour distinguer l’attribut provenant de la classe de base, l’une

des façons suivantes est utilisée :
 Le précéder par super
 Le précéder par une référence de l’instance en question
((ClasseBase)this). En réalité, l’instance de la classe
dérivée cache une instance de la classe de base
 Il s’agit, dans tous les cas d’une solution à éviter car elle
présente beaucoup d’ambiguïté, surtout avec plusieurs niveaux
d’héritage.

Exemple :
class B
{
protected int x, y;
{ System.out.println("x= "+x+" y= "+y); }
}
class HB extends B
{
private double x;
private int y, z;
public HB(double a,int b)
{
//super();
x=a;z=b;
}
{
//super.afficher();
System.out.println(" x de base ="+((B)this).x+
" y de base ="+super.y+
" x="+this.x+ " y="+y+ " z="+z); }
}
public class THB
{
{
HB hb = new HB(6.5,13);
hb.afficher();
}
}

5. Classe et méthode finales
 JAVA permet d'interdire l'héritage d'une classe en la déclarant

avec le modificateur final
 JAVA permet d'interdire la redéfinition d'une méthode (si elle est

héritée) en la déclarant avec le modificateur final

6. Nouveau spectre pour les références d'objets
 Une référence d'une classe de Base peut désigner un objet

d'une classe Dérivée
 L'opérateur de casting peut être utilisé pour convertir une

référence déclarée de type classe de Base en une référence de
type classe Dérivée (pour un objet de la classe Dérivée)

Exemple :

{
public static void main (String [] args)
{
Etudiant e; Personne p1,p2;
p1 = new Etudiant("Ali","Mohamed","Adr1",12, "LFIG",2);
e=(Etudiant) p1;
e.afficher(); // p1.afficher() ;
p2=e; // p1,p2 et e désignent le même objet
}
}

7. Les règles de visibilité des membres
d’une classe
 Les règles de visibilité fonctionnent au niveau des classes à
celui des objets. Un objet peut parfaitement accéder à la
méthode privée d'un autre objet si celui-ci est de la même
classe
 Le membre hérité est de modificateur public :
Toutes les méthodes de toutes les classes peuvent accéder
au membre hérité, quelque soit leurs emplacements
 Le membre hérité est de modificateur private :
Les méthodes de la classe de base (faisant partie de la
même classe de définition de l’attribut en question) sont les
seules à être autorisées à accéder au membre hérité
 Lemembre hérité est de modificateur protected :
L’accès est permis aux :
 méthodes de la classe de base (faisant partie de la même
classe de définition de l’attribut en question)
 méthodes des classes dérivées quelque soit leurs
emplacements
 méthodes du même package
 Lemembre hérité est de modificateur friendly :

L’accès est permis aux :
 méthodes de la classe de base (faisant partie de la même
classe de définition de l’attribut en question)
 méthodes du même package

Classes dérivées Classes du Classes dérivées Classes des
même
Accès : dans le même même dans un autre autres
classe
package package package packages
public X X X X X
protected X X X X
par défaut X X X
(friendly)
Private X

8. Le polymorphisme
8.1. Les méthodes polymorphes
 Une méthode polymorphe est une méthode déclarée dans une

super-classe et redéfinie par une sous-classe
 Les méthodes polymorphes permettent de prévoir des

opérations similaires sur des objets de natures différentes
 Les méthodes final ne peuvent être redéfinies et ne sont donc

pas polymorphes

8.2. Définition du polymorphisme
 Il s'agit d'invoquer (appeler) des méthodes sans connaître la
nature de l'objet correspondant
 L'appel se fait à partir d'une référence du même type que l'objet

correspondant ou de type sa classe de base (on peut remonter
à tous les niveaux de ses classes de base)
 Grâce au polymorphisme, une même écriture peut correspondre

à différents appels de méthodes
Exemple :
A a = meth.creationObjet();
// meth renvoie un objet de type A ou d’un type dérivé de A
a.m();
//peut appeler la méthode m() de A ou de n’importe
//quelle sous-classe de A
8.2.1. Mécanisme du polymorphisme
 Le polymorphisme est obtenu grâce à un mécanisme

dynamique appelé late binding (liaison retardée)
 La méthode qui sera exécutée est alors déterminée :

 Seulement à l’exécution, et pas dès la compilation
 Par le type réel de l’objet qui reçoit le message et pas par le
type de la référence qui le désigne (gestion d'un pointeur sur
la description de la classe de l'objet)

8.2.2. Mécanisme de la liaison retardée
 Soit C la classe réelle d'un objet o à qui on envoie un message

"o.m()"
 Si le code de la classe C contient la définition (ou la

redéfinition) d’une méthode m(), c’est cette méthode qui sera
exécutée
 Sinon, la recherche de la méthode m() se poursuit dans la
classe mère de C, puis dans la classe mère de cette classe
mère, et ainsi de suite, jusqu’à trouver la définition d’une
méthode m() qui est alors exécutée

8.2.3. Intérêts du polymorphisme
 Le polymorphisme minimise l’écriture du code
 Le polymorphisme favorise la propriété d'extension des

applications
 On peut créer de nouvelles sous-classes dont les instances

pourront être prises en compte sans toucher aux
programmes déjà écrits

Exemple :
class Personne
{
public void quiEtesVous() {System.out.println("personne");}
…
}
{
public void quiEtesVous() {System.out.println("étudiant");}
…
}
class Employe extends Personne
{
public void quiEtesVous() {System.out.println("employé");}
…
}
public class Polymorphisme
{
{Personne p; int x;
System.out.println(Taper 1,2 ou 3) ;
x=Clavier.lireInt();
if (x = =1)
p= new Personne();
else
if (x = = 2)
p = new Etudiant();
else
p = new Employe();
p.quiEtesVous(); //appel polymorphe
}
}
Chapitre 6 :
Les classes abstraites et les

interfaces
1. Idée de base d’une classe abstraite
 Par opposition à une classe concrète, une classe abstraite ne
peut pas être instancier
 L'utilité d'une classe abstraite est de définir un type abstrait qui
regroupe des caractéristiques communes à d'autres types. En
effet, elle sert :
 Comme racine pour un sous-arbre d’héritage :
 Dans lequel les sous-classes apporteront leurs
particularités
 Favorise le polymorphisme
 Au partage de certaines descriptions :

 Variables d’instances (ou de classes) communes
 Méthodes définissant un comportement par défaut

 Une méthode d'une classe abstraite peut ne pas avoir de code
(abstraite) si le niveau d'abstraction de la classe ne permet pas
de définir un code réutilisable par les classes à dériver
Exemple : Document : Livre, Revue, …
 Une classe est définie abstraite par obligation (présence d’au

moins une méthode abstraite) ou par choix pour interdire la
création d’objet

2. Définition d’une classe abstraite en JAVA
 Une classe abstraite est déclarée avec le mot clé abstract
Exemple : abstract class Document {….}
 Une classe abstraite ne peut jamais être instanciée par
l'opérateur new
 On peut déclarer des références de type classe abstraite
 La méthode abstraite est aussi déclarée avec le mot clé
abstract.
Exemple : abstract class ObjetGraphique
{abstract float surface ();
…
}
 Si une classe comporte une méthode abstraite elle doit être
déclarée abstraite
 Une classe abstraite peut ne pas comporter de méthodes

abstraites
 Toute classe concrète dérivée à partir d'une classe abstraite doit

donner un code aux méthodes abstraites héritées, si non elle doit
être déclarée abstraite (l'abstraction continue)
 On ne peut pas combiner les modificateurs abstract et final

3. Les interfaces
 Une interface est une forme particulière de classe qui comporte
uniquement des propriétés abstraites
 Le concept d'interface est proposé par le langage JAVA pour

résoudre le problème de l'héritage multiple
 Une interface peut hériter de plusieurs interfaces en même

temps en utilisant le mot clé extends (héritage multiple)
 Comparée à une classe, une interface correspond à un type

comportant uniquement des méthodes abstraites et des
constantes statiques (on a pas à préciser les modificateurs
abstract, final et static)
 Les interfaces ne sont pas instanciables

 L’utilisation des interfaces permet de :
 Définir (regrouper) des propriétés qui peuvent être

transférées aux classes par un mécanisme particulier
(l’implémentation)
 Garantir aux clients d’une classe que ses instances peuvent
assurer certains services, ou qu’elles possèdent certaines
propriétés (par exemple, être comparables à d’autres
instances)
 Faire du polymorphisme avec des objets dont les classes
n’appartiennent pas à la même hiérarchie d’héritage
(l’interface joue le rôle de la classe mère)

 Une interface est définie d'une manière similaire à une classe
mais en utilisant le mot clé interface
 La syntaxe de déclaration d'une interface est la suivante :

interface NomInterface { … }
Exemples :
interface Edition
{void editer();}
interface Affichage
{int MIN = 0;
int MAX=100;
void afficher();
}

4. Interfaces et héritage
 Une interface peut hériter d'une ou de plusieurs autres
interfaces. Il s'agit d'une extension de propriétés sous forme de
méthodes abstraites et de constantes statiques.
Exemple :
interface InputStream // propriété d'accepter des caractères
{public int read(); }
interface OutputStream // propriété de fournir des caractères
{public void write(int n); }
interface DataStream extends InputStream, OutputStream
{public double readDouble();
public void writeDouble(double x);
}
5.Implémentation d’une interface
 Une classe peut implémenter plusieurs interfaces, c'est à dire

avoir les même caractéristiques (ou propriétés) définies au
niveau de ces interfaces. Réciproquement, la même interface
peut être implémentée par plusieurs classes
 L'implémentation est une forme d'héritage multiple
 Il est possible de combiner, lors de la définition d'une classe,

l'héritage et l'implémentation d'interfaces

Exemple :
interface Printable // propriété d'être imprimé

{public void print(); }
class MonStream implements DataStream, Printable
{
public void print() { …}
public int read() { …}
public void write(int n) { …}
public double readDouble(){ …}
public void writeDouble(double x) { …}
}

6.Les références de type interface
 Il est possible de déclarer des références de type interface afin
de désigner des objets qui implémentent l'interface en question.
Les objets désignés peuvent être de types différents
 L'opérateur instanceof peut être utilisé pour savoir si un objet

implémente une interface donnée

Langue

Poo 2mioad 14 15

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Poo 2mioad 14 15

Titre original :

Transféré par

Droits d'auteur :

Faculté des Sciences Économiques et de Gestion de Sfax

Année Universitaire : 2014-2015

Chapitre 1 : Introduction générale

Chapitre 2 : Les éléments de base du langage JAVA

Chapitre 3 : Les classes et les objets

Chapitre 4 : Les tableaux et les chaînes de caractères

Chapitre 5 : L'héritage et le polymorphisme

Chapitre 6 : Les classes abstraites et les interfaces

Cours de Programmation Orientée Objet 3

 La programmation classique reposait sur cette équation:

Programmes = Algorithmes + Structures de données

Cours de Programmation Orientée Objet 4

 La programmation orientée objet consiste à représenter les

Programme = ensemble d’objets communicants

Cours de Programmation Orientée Objet 5

 Elle permet donc de garantir l'intégrité des données contenues

Cours de Programmation Orientée Objet 6

Objet = Attributs + Méthodes

Cours de Programmation Orientée Objet 7

Cours de Programmation Orientée Objet 8

changerFiliere() changerFiliere () changerFiliere () changerFiliere ()

Cours de Programmation Orientée Objet 10

Cours de Programmation Orientée Objet 11

Cours de Programmation Orientée Objet 12

Programmation classique POO

Cours de Programmation Orientée Objet 14

Cours de Programmation Orientée Objet 15

Cours de Programmation Orientée Objet 16

(1) : Compilation JVM PC

Cours de Programmation Orientée Objet 17

Cours de Programmation Orientée Objet 18

Cours de Programmation Orientée Objet 19

Cours de Programmation Orientée Objet 20

 Tout fichier source doit porter le nom de la classe publique qu'il

Cours de Programmation Orientée Objet 21

Cours de Programmation Orientée Objet 22

Cours de Programmation Orientée Objet 23

Cours de Programmation Orientée Objet 24

Les éléments de base du

long 8 octets signé -9223372036854775808 9223372036854775807

float 4 octets signé … …

 Les conversions implicites légales en JAVA sont :

Les classes et les objets

Cours de Programmation Orientée Objet 45

aux propriétés (attributs et méthodes) de ses objets.

Cours de Programmation Orientée Objet 46

Cours de Programmation Orientée Objet 47

Cours de Programmation Orientée Objet 48

Cours de Programmation Orientée Objet 49

En JAVA, la syntaxe de déclaration d'un attribut est la suivante :

Cours de Programmation Orientée Objet 50

Cours de Programmation Orientée Objet 51

En JAVA, la syntaxe de déclaration d'une méthode est la

Cours de Programmation Orientée Objet 53

 Le nom d'une variable locale est en minuscule (si non final)

 Une méthode peut être surchargée : définition, au sein d'une

Cours de Programmation Orientée Objet 54

Cours de Programmation Orientée Objet 56

Cours de Programmation Orientée Objet 57

 Allouer l'espace mémoire nécessaire pour stocker les

 Appeler le constructeur de l'objet adéquat pour initialiser les

 Retourner une référence sur l'objet créé

Cours de Programmation Orientée Objet 58

Cours de Programmation Orientée Objet 59