Vous êtes sur la page 1sur 168

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


Cours de Programmation Orientée Objet 1
Chapitre 1 :

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

Cours de Programmation Orientée Objet 3


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

Cours de Programmation Orientée Objet 4


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

Cours de Programmation Orientée Objet 5


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.

Cours de Programmation Orientée Objet 6


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

Cours de Programmation Orientée Objet 7


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:

Cours de Programmation Orientée Objet 8


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 ()
Cours de Programmation Orientée Objet 9
Exercice
xxxxxxxxx

Cours de Programmation Orientée Objet 10


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.

Cours de Programmation Orientée Objet 11


Exercice (suite)
xxxxxxxxx

Cours de Programmation Orientée Objet 12


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
Cours de Programmation Orientée Objet 13
Attributs
fonction Méthodes de l’objet

fonction de l’objet

fonction données
globales Attributs
fonction de l’objet
Méthodee

fonction de l’objet

Attributs
Méthodes de l’objet

de l’objet

Programmation classique POO

Cours de Programmation Orientée Objet 14


2. Le langage JAVA

Cours de Programmation Orientée Objet 15


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.

Cours de Programmation Orientée Objet 16


 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

Cours de Programmation Orientée Objet 17


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 …

Cours de Programmation Orientée Objet 18


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

Cours de Programmation Orientée Objet 19


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.

Cours de Programmation Orientée Objet 20


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"

Cours de Programmation Orientée Objet 21


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");
}
}

Cours de Programmation Orientée Objet 22


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

Cours de Programmation Orientée Objet 23


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

Cours de Programmation Orientée Objet 24


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

Cours de Programmation Orientée Objet 45


 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

Cours de Programmation Orientée Objet 46


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

Cours de Programmation Orientée Objet 47


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
}

Cours de Programmation Orientée Objet 48


 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

Cours de Programmation Orientée Objet 49


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];

Cours de Programmation Orientée Objet 50


 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

Cours de Programmation Orientée Objet 51


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;]
}
Cours de Programmation Orientée Objet 52
 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

Cours de Programmation Orientée Objet 53


 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)

Cours de Programmation Orientée Objet 54


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.

Cours de Programmation Orientée Objet 56


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.

Cours de Programmation Orientée Objet 57


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éé

Cours de Programmation Orientée Objet 58


 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();
}
}

Cours de Programmation Orientée Objet 59


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).

Cours de Programmation Orientée Objet 60


Exemple:
class Etudiant
{ 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 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;}
Cours de Programmation Orientée Objet 61
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;}
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 62


Cours de Programmation Orientée Objet 63
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()

Cours de Programmation Orientée Objet 64


Exemple:
class Etudiant
{ private int matricule;
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 ++;}
Cours de Programmation Orientée Objet 65
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 ++;}
public void changerFiliere(String f)
{filiere = f;}
public void changerNiveau (int n)
{niveau = n;}
public void changerGroupe (int g)
{groupe = g;}
protected void finalize()
{ nbEtudiant--; }
}

Cours de Programmation Orientée Objet 66


Cours de Programmation Orientée Objet 67
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
Cours de Programmation Orientée Objet 68
 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

Cours de Programmation Orientée Objet 69


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.

Cours de Programmation Orientée Objet 70


 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.

Cours de Programmation Orientée Objet 71


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.

Cours de Programmation Orientée Objet 72


 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).

Cours de Programmation Orientée Objet 73


Exemple :

public class TestEtudiant


{
public static void main(String [] args)
{ 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
}
}
Cours de Programmation Orientée Objet 74
Cours de Programmation Orientée Objet 75
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.

Cours de Programmation Orientée Objet 76


Exemple :

class Etudiant
{ private int matricule;
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; }

}

Cours de Programmation Orientée Objet 77


Cours de Programmation Orientée Objet 78
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

Cours de Programmation Orientée Objet 79


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).

Cours de Programmation Orientée Objet 80


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 );
}
}
Cours de Programmation Orientée Objet 81
class Etudiant
{
private Stage stage;
private int matricule;

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
}

Cours de Programmation Orientée Objet 82


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");
}
}
Cours de Programmation Orientée Objet 83
Cours de Programmation Orientée Objet 84
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

Cours de Programmation Orientée Objet 85


Exemple :
class Etudiant
{
private int matricule;

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());
}
}
Cours de Programmation Orientée Objet 86
Cours de Programmation Orientée Objet 87
 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)

Cours de Programmation Orientée Objet 88


Exemple :
class Etudiant
{
private int matricule;

public String filiere;

public String toString()
{
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;
}

}
Cours de Programmation Orientée Objet 89
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);
}
}

Cours de Programmation Orientée Objet 90


Cours de Programmation Orientée Objet 91
Chapitre 4 :

Les tableaux et les chaînes de


caractères
1. Les tableaux

1.1. Déclaration

1.2. Création et initialisation

Cours de Programmation Orientée Objet 93


 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

Cours de Programmation Orientée Objet 94


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] :

Cours de Programmation Orientée Objet 95


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

Cours de Programmation Orientée Objet 96


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 :

Cours de Programmation Orientée Objet 97


- 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.

Cours de Programmation Orientée Objet 98


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

Cours de Programmation Orientée Objet 99


 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

Cours de Programmation Orientée Objet 100


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

Cours de Programmation Orientée Objet 101


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

Cours de Programmation Orientée Objet 102


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.

Cours de Programmation Orientée Objet 103


Cours de Programmation Orientée Objet 104
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
Cours de Programmation Orientée Objet 105
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.

Cours de Programmation Orientée Objet 106


Exemple :
public class TestEtudiant
{
public static void main(String [] args)
{
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
}
}

Cours de Programmation Orientée Objet 107


Cours de Programmation Orientée Objet 108
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

Cours de Programmation Orientée Objet 109


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
}
}

Cours de Programmation Orientée Objet 110


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

Cours de Programmation Orientée Objet 111


Exemple :
class TestString
{
public static void main(String [] args)
{
String ch1,ch2;
ch1="Programmation";
ch2=ch1;
System.out.println("ch1: " +ch1);//Programmation
System.out.println("ch2: " +ch2);//Programmation
ch1+=" en JAVA"; //Création d'un nouvel objet
System.out.println("ch1: " +ch1);//Programmation en JAVA
System.out.println("ch2: " +ch2);//Programmation
Ch1=Clavier.lireString();//encore un nouvel objet
}
}
Cours de Programmation Orientée Objet 112
Cours de Programmation Orientée Objet 113
 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
Cours de Programmation Orientée Objet 114
 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

Cours de Programmation Orientée Objet 115


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)

Cours de Programmation Orientée Objet 116


 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
Cours de Programmation Orientée Objet 117
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)

Cours de Programmation Orientée Objet 119


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)

Cours de Programmation Orientée Objet 120


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.
Cours de Programmation Orientée Objet 121
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)

Cours de Programmation Orientée Objet 122


 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

Cours de Programmation Orientée Objet 123


Exemple :
class Personne
{
private String nom;
private String prenom;
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;}
}

Cours de Programmation Orientée Objet 124


Exemple :

class Etudiant extends Personne


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

Cours de Programmation Orientée Objet 125


Cours de Programmation Orientée Objet 126
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)
Cours de Programmation Orientée Objet 127
Exemple :
class Personne
{
public Personne (String n, String p, String adr)
{ nom = n, prenom = p; adresse=adr;}

}
class Etudiant extends Personne
{
public Etudiant (String n, String p, String adr, int m, String f, int niv)
{super(n,p,adr);
matricule = m;
filiere=f;
niveau=niv;
}

} Cours de Programmation Orientée Objet 128
Cours de Programmation Orientée Objet 129
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é)

Cours de Programmation Orientée Objet 130


 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 prenom;
private String adresse;

public String getPrenom()
{return prenom;}
public String getAdresse()
{return adresse;}

} 131
Cours de Programmation Orientée Objet
class Etudiant extends Personne
{

public String toString()
{
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);
}

}

Cours de Programmation Orientée Objet 132


Cours de Programmation Orientée Objet 133
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
Cours de Programmation Orientée Objet 134
 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

Cours de Programmation Orientée Objet 135


Exemple :
class Etudiant extends Personne
{

public void afficher()
{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);
}
} Cours de Programmation Orientée Objet 136
Cours de Programmation Orientée Objet 137
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.

Cours de Programmation Orientée Objet 138


Exemple :
class B
{
protected int x, y;
public void afficher()
{ 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;
}
Cours de Programmation Orientée Objet 139
public void afficher()
{
//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
{
public static void main(String [] args)
{
HB hb = new HB(6.5,13);
hb.afficher();
}
}

Cours de Programmation Orientée Objet 140


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

Cours de Programmation Orientée Objet 141


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)

Cours de Programmation Orientée Objet 142


Exemple :

public class TestEtudiant


{
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
}
}

Cours de Programmation Orientée Objet 143


Cours de Programmation Orientée Objet 144
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é
Cours de Programmation Orientée Objet 145
 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

Cours de Programmation Orientée Objet 146


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

Cours de Programmation Orientée Objet 147


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

Cours de Programmation Orientée Objet 148


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
Cours de Programmation Orientée Objet 149
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)

Cours de Programmation Orientée Objet 150


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

Cours de Programmation Orientée Objet 151


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

Cours de Programmation Orientée Objet 152


Exemple :
class Personne
{
public void quiEtesVous() {System.out.println("personne");}

}
class Etudiant extends Personne
{
public void quiEtesVous() {System.out.println("étudiant");}

}
class Employe extends Personne
{
public void quiEtesVous() {System.out.println("employé");}

}
Cours de Programmation Orientée Objet 153
public class Polymorphisme
{
public static void main(String [] args)
{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
}
}
Cours de Programmation Orientée Objet 154
Cours de Programmation Orientée Objet 155
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

Cours de Programmation Orientée Objet 157


 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

Cours de Programmation Orientée Objet 158


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 ();

}
Cours de Programmation Orientée Objet 159
 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

Cours de Programmation Orientée Objet 160


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


Cours de Programmation Orientée Objet 161
 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)

Cours de Programmation Orientée Objet 162


 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();
}

Cours de Programmation Orientée Objet 163


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);
}
Cours de Programmation Orientée Objet 164
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

Cours de Programmation Orientée Objet 165


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) { …}
}

Cours de Programmation Orientée Objet 166


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

Cours de Programmation Orientée Objet 167

Vous aimerez peut-être aussi