1

2
 Objectif: réutilisation

 Concepts de base:
 Objet et classe
 Héritage
 Encapsulation
 Polymorphisme
 Abstraction
 Interface

3
 Le concept de classe est une généralisation de la notion type.
 La classe est une généralisation d’un ensemble d’objets ayant une structure de
données commune et disposant des mêmes méthodes.
 Instancier une classe consiste à créer un objet sur son modèle
 Chaque objet appartient à une classe
 Un objet est caractérisé par un état (attributs) et un comportement (méthodes)
 L’état d’un objet peut changer dans le temps (généralement par le
comportement)
 Chaque objet possède une identité propre à lui appelée référence (adresse
mémoire)

4
 Mode d’accès: visible uniquement pour les méthodes de la classe Personne
Type des attributs
Méthodes

Instanciation: création d’un objet ahmed de type Personne

Appel des méthodes de la classe Personne sur l’objet ahmed 5

 Décrit l’état de l’objet
 Peut être de type primitif ou de type de référence
 Défini par:
 Un mode d’accès
 Un type
 Un nom

 Syntaxe:
Mode d’accès type nom;
Ps: un attribut est initialisé soit implicitement à la valeur initiale par défaut, soit
explicitement, soit avec un constructeur.

6
 En Java, une méthode est définie dans une classe . Elle implémente les traitements de la classe.
 Elle est définie par :
 Un mode d’accès
 un type de retour
 un nom
 une liste (éventuellement vide) de paramètres typés en entrée
 une suite d’instructions (un bloc d’instructions) qui constitue le corps de la méthode

 Syntaxe:
Mode d’accès typeRetour nomMethode ( « Liste des paramètres » ) {
/*
corps de la méthode
*/
}

7
 Une méthode ne fournir aucun résultat (void) ou fournit un résultat en retour. cette dernière est appelé
méthode fonction
 Exemple : public int calculeAge() //une méthode fonction qui retourne un entier.
 Les arguments muets d’une méthode sont les paramètres utilisés lors de sa définition.
 Les arguments effectifs sont utilisés lors de l’appel de la méthode.
 Exemple:
Public void setName(String name){ //name est un argument muet
….
}
….
p.setName("ahmed"); //argument effectif

PS: le type de l’argument effectif doit être identique ou convertible au type de l’argument muet.

8
 Constructeur: une méthode appelée au moment de la création d’un objet elle est:
 sans valeur de retour
 portant le nom de la classe
 peut disposer d’un nombre quelconque d’arguments

 Une classe peut posséder 0 ou plusieurs constructeurs

 Personne ahmed = new Personne() //correct si Personne ne possède aucun constructeur
 Personne ahmed = new Personne() // incorrect si Personne possède un constructeur avec paramètres

 Un constructeur privé ne peut pas être appelé de l’extérieur et ne peut plus être utilisé
pour instancier les objets.
9
 Le constructeur initialise explicitement ou implicitement les valeurs des attributs.
 Accesseurs et mutateurs
Afin d’accéder à un attribut pour changer sa valeur (en écriture) ou pour
récupérer sa valeur (en lecture) on utilise:
 Accesseur (getter) pour récupérer la valeur de l’attribut nom d’un objet de type Personne:

 Mutateur (setter) pour changer la valeur de l’attribut nom d’un objet de type Personne:

10
 Personne ahmed;
 Est correct
 Ne réserve pas un espace mémoire
 Réserve seulement un emplacement pour une référence à un objet de type personne

 Personne ahmed = new Personne();

 Reserve un emplacement pour un objet
 Fournit comme résultat la référence de l’objet

 Une fois l’objet initialisé, les méthodes peuvent s’appliquer sur lui;

ahmed
p
10/04/1995

Personne p = new Personne();

11
o Fonctionnement général: La création d'un objet fait intervenir les phases
suivantes:
 allocation de mémoire;
 initialisation par défaut des champs (aux valeurs "nulles" habituelles );
 initialisation explicite, s’il y a lieu, des champs (aux valeurs données par le
programmeur lors de la déclaration);
 exécution des instructions du constructeur.

12
 private, public protected
o Ces trois modificateurs peuvent être combinés pour modifier la visibilité des
classes, méthodes, variables.
 public : classes, méthodes, variables déclarées « public » sont visibles par toutes les
autres méthodes que ce soit à l'intérieur ou à l'extérieur du package de définition.
(contraire au principe d’encapsulation)
 protected : méthodes, variables ( protected n'est pas autorisé pour les classes)
déclarées « protected » ne sont accessibles que par les méthodes de la classe et des sous-
classe du package de l'objet de définition.
 private : c'est le degré de restriction le plus fort ; seules les méthodes de la même classe
peuvent voir une entité (variable ou méthode) déclarée private .

13
14
 Créés en utilisant le mot clé static,
 Un attribut de classe est un champ qui existe dans toutes les instances de la classe. Il a la même valeur
quelque soit l’objet. (données globale partagée entre tous les objets de la même classe)
 Exemple: public static int nombrePersonnes;

 Une méthode de classe est une méthode qui opère un traitement indépendant des objets. Une méthode static
ne peut agir que sur les attributs static.
 Exemple:
public static int getNombre (){
return nombrePersonnes;
}
 l’appel d’un champ de classe ou méthode de classe fait directement en utilisant uniquement le nom de la
classe.
 Exemple:
Personne. nombrePersonnes;
Personne.getNombre ();

15
 Appelée aussi surdéfinition: plusieurs méthodes dans la même classe peuvent
porter les même noms à condition qu’elles aient des signatures différentes. (leurs
paramètres sont différents pour permettre au compilateur de choisir)

 Exemple:
 Supposons que la méthode public int calculerAge(String nom) existe dans la
classe personne. Java nous permet de créer aussi des méthodes comme:
 public int calculerAge() //ok
 public int calculerAge(LocalDate dateNaissance) //ok
 public int calculerAge(String nom, LocalDate dateNaissance) //ok
 Cependant, il est impossible de créer les méthodes:
 public int calculerAge(String nom) //ko mêmes arguments
 public float calculerAge(String nom) //ko mêmes arguments

16
 Permet de disposer de plusieurs constructeurs dans la même classe. On peut
donc créer différentes instances selon le constructeur utilisé.

17
 Peut créer des d’ambiguïtés (cas de conversion)

18
Programme Résultat

a = b; recopie simplement dans a la référence qui se trouve dans b. Donc a contient la

référence de b. a et b pointent vers le même objet.
- Si l’un des deux modifie l’objet, l’autre sera impacté!!
- Ps: Pour créer un objet b qui est une copie séparée de l’objet a il faut tout simplement créer
une méthode dans la classe Personne qui retourne un nouvel objet contenant les valeur
des attributs de a.

19
  Les opérateurs == et != s'appliquent théoriquement à des objets.
 L'expression a == b est vraie uniquement si a et b font référence à un seul et
même objet, et non pas seulement si les valeurs des champs de a et b sont les
mêmes.
 Exemple:

 Résultat: différent

20
 Exemple

 Résultat: égaux

21
 Deux modes pour l’échange d’information avec les méthodes:
 Par valeur: la méthode utilise une copie de la valeur de l’argument. L’argument lui
reste inchangée.
 Par référence: la méthode reçoit une référence vers l’argument. La méthode peut
ainsi modifier directement sa valeur.

 Java transfert les données par valeur. mais quand la valeur concerne un
objet (qui est au fait une référence), la méthode peut ainsi modifier l’objet
comme s’il s’agissait d’un transfert par référence.

22
 Java ne propose pas d’opérateur pour détruire un objet dont on a plus
besoin.
 Il existe un mécanisme de gestion automatique de la mémoire qui s’appelle le
ramasse-miettes (ou Garbadge Collector) qui libère l’espace des objets qui
n’ont aucune référence.
 S’exécute manuellement ou dès que la mémoire disponible est inférieur à un
seuil.
 Risque de diminution de performance

23
 Une classe interne est définie au sein d’une autre classe externe
 Exemple

 Permet d’instancier dans les méthodes de E un objet local de type I.

 N’implique pas forcément que l’un des attributs de E est de type I.

 Permet d’avoir au sein de E des attribut de type I

 3 propriétés particulières par rapport à si I était une classe externe:

 Un objet de la classe interne est toujours associé à un objet de la classe externe qui lui a donné naissance
 Un objet de classe interne a toujours accès aux champs et méthodes (même privés) de l’objet de la classe externe.
(attention: il s’agit de l’objet en cours mais pas tous les objets)
 Un objet de classe externe a toujours accès aux champs et méthodes (même privés) de l’objet de la classe interne.

24
o Construire une classe qui représente un point, Chaque instance (objet) de
cette classe appelée Point possède 2 attributs privés x et y qui représentent
les coordonnées du point. Les cordonnées peuvent être fixées pendant la
construction du point, sinon on peut les changer après à l’aide des getters
et des setters. Proposer une méthode changerCoordonnées(int x, int y) qui
change à la fois les attributs x et y d’un point.
o Construire une deuxième classe qui représente un cercle, chaque instance
de cette classe possède 2 attributs privés o et r qui représentent
successivement le centre (de type point) et le rayon du cercle. On définit
lors de la construction le rayon r du cercle, puis on définit un getter et un
setter pour les deux attributs.
o Dans la classe de test, construire (instancier) un objet o de type Point (en
fixant x et y pendant la construction) et un objet cercle de type Cercle. Puis
définir o comme le centre de cercle. Ensuite utiliser le getter de cercle pour
afficher les cordonnées de o.

25
 Un des fondements de la programmation orientée objet, Il permet la réutilisation
de code: gain temps de développement et de maintenance.
 Une classe fille (dérivée, sou-classe) hérite les attributs et les méthodes de sa
classe mère (de base, sur-classe).
 Une classe fille ne va donc définir que les attributs et méthodes qui la
différencient de la classe mère
 En java le mot clé extends permet de spécifier, dans la classe fille, le nom de la
classe mère.
 Une classe fille hérite tout d’une classe mère. Sauf le constructeur.
 Dans java toutes les classes héritent d’une seule classe
 explicitement avec extends,
 implicitement de la classe Object

26
27
 Le constructeur de la classe fille doit prendre en charge la construction de
l’intégralité de l’objet.
 Le constructeur de la classe fille peut appeler le constructeur de la classe mère
avec la méthode super() //tenir compte des paramètres!

 l’instruction «super(nomP, dateP); » fait un appel au constructeur de la classe Personne

qui est la super-classe de Employé. Elle initialise les deux attributs nom et dateNaissance.
Il reste donc à ajouter l’instruction « salaire=salaireP; » pour initialiser l’attribut salaire
 L’appel à l’instruction super doit obligatoirement être la première instruction du
constructeur.

28
 Instanciation des objets: (rappel)
o Dans le cas général des classes simples, la création d'un objet (A a = new A(…)) fait
intervenir les phases suivantes:
 allocation de mémoire;
 initialisation par défaut des champs (aux valeurs "nulles" habituelles );
 initialisation explicite, s’il y a lieu, des champs (aux valeurs données par le programmeur
lors de la déclaration);
 exécution des instructions du constructeur.

29
 Instanciation d’un objet d’une classe dérivée:

 Supposons que: public class B extends A { ... }

o La création d'un objet de type B ( B b = new B(…); ) se déroule en 6 étapes.
 Allocation mémoire pour un objet de type B ; il s'agit bien de l'intégralité de la mémoire
nécessaire pour un tel objet, et pas seulement pour les champs propres à B (c'est-à-dire
non hérités de A).
 Initialisation par défaut de tous les champs de B (aussi bien ceux hérités de A, que ceux
propres à B) aux valeurs "nulles" habituelles.
 Initialisation explicite, s'il y a lieu, des champs hérités de A, éventuellement, exécution des
blocs d'initialisation de A.
 Exécution du corps du constructeur de A.
 Initialisation explicite, s'il y a lieu, des champs propres à B ; éventuellement, exécution des
blocs d'initialisation de B.
 Exécution du corps du constructeur de B.

30
 Dérivations successives :
o Le cas ou la classe fille est aussi une classe mère de plusieurs autres
classes filles….
o Exemple

o La classe VéhiculeTerrestre est en même temps classe dérivée de

Véhicule et classe de base pour Voiture et Camion.
31
 Héritage multiple

o Contrairement au C++, Java ne gère pas les héritages multiples :

une classe dérivée (ou encore classe fille) ne peut hériter que d'une
seule classe mère !
o L’instruction ci-dessous est donc impossible

32
 Redéfinition des méthodes
 Supposons que nous souhaitons avoir une méthode affiche() dans la classe
personne qui affiche les informations sur le nom et la date de naissance de l’objet
en cours.
 La méthode serait de la forme:

 L’appel de la méthode affiche par un objet Employé ne contiendra pas les

informations sur le salaire.
Ps: Le mot clé this sert à référencer l’objet courant

33
 Redéfinition des méthodes
 Solution: Redéfinir la méthode affiche() dans la classe Employé tout en réutilisant celle
de la classe personne. On peut donc dans la classe Employé ajouter:

 Cette possibilité existe en Java; elle se nomme redéfinition de méthode. Elle permet à
une classe dérivée de redéfinir une méthode de sa classe de base, en proposant une
nouvelle définition. Encore faut-il respecter la signature de la méthode (type des
arguments), ainsi que le type de la valeur de retour.
 Résultat: l’appel de la méthode affiche par un objet Employé affichera aussi le salaire
PS: les attributs nom et dateNaissance étant privés, il est impossible d’afficher
directement leurs valeurs sans passer par la méthode affiche() de la classe Personne.

34
 Redéfinition des méthodes
o La redéfinition d'une méthode s'applique à une classe et à toutes ses
descendantes jusqu'à ce que éventuellement l'une d'entre elles
redéfinisse à nouveau la méthode.
o Exemple:
(*) signale la définition ou la redéfinition d'une méthode f

35
 Surcharge (ou Surdéfinition) et héritage
o Jusqu'à maintenant, nous n'avions considéré la surdéfinition qu'au sein d'une
même classe. En Java, une classe dérivée peut surdéfinir une méthode d'une classe
de base (ou, plus généralement, d'une classe ascendante). En voici un exemple :

36
 Contraintes portant sur la redéfinition
o Valeur de retour
 Lorsqu'on surdéfinit une méthode, on n'est pas obligé de respecter le type de la valeur de
retour. Cet exemple est légal :

37
 Contraintes portant sur la redéfinition
o Valeur de retour (Suite)
 En revanche, en cas de redéfinition, Java impose non seulement l'identité des signatures, mais aussi
celle du type de la valeur de retour :

 Ici, on n'a pas affaire à une surdéfinition de f puisque la signature de la méthode est la même dans A et
dans B. Il devrait donc s'agir d'une redéfinition, mais comme les types de retour sont différents, on
aboutit à une erreur de compilation !!

38
 Contraintes portant sur la redéfinition
o Les droits d’accès
 Exemple:

 Attention : La redéfinition d'une méthode ne doit pas diminuer les droits d'accès à cette méthode.

39
 Notion de la POO qui complète l’héritage.
 Permet d’affecter à un objet
 La référence vers un objet de type correspondant
 la référence à un objet de type dérivé. (conversion implicite)

 Le polymorphisme se caractérise par la ligature dynamique des méthodes

 Exemple:

 P est de type Personne mais référence un objet de type Employé

40
 Une variable final ne peut pas être modifiée.
 Une classe finale ne peut pas avoir de classe fille
 Une méthode finale ne peut pas être redéfinie dans une classe fille

41
 Une classe abstraite permet de définir dans une classe mère les fonctionnalités communes entre
toutes ses classes filles
 Une classe abstraite ne peut pas être utilisée pour instancier des objets.
 Une classe abstraite ne sert que pour une classe mère.
Exemple:

 Une classe abstraite permet de définir des méthodes abstraites.

 Une méthode abstraite est une méthode qui n’est pas définie (qui ne contiennent pas de corps).
Exemple:

/
42
 Quelques règles:
 Une classe est abstraite dès qu’elle comporte une méthode abstraite. (bien que le
mot abstract peut être omis)
 Une méthode abstraite ne peut pas être finale
 Une méthode abstraite doit être public
 Une classe dérivée d'une classe abstraite n'est pas obligée de redéfinir toutes les
méthodes abstraites de sa classe de base.

43
 Une interface est un type de classe abstraite qui ne contient que des méthodes
abstraites.
 Les Interfaces permettent d’implémenter la notion de contrat.
 Les interfaces peuvent contenir uniquement des définitions de constantes et
des déclarations de méthodes, sans leur définition (autrement dit, les
méthodes indiquées dans les interfaces ne comportent que le prototype sans
le corps).
Exemple:

public interface I {
public abstract void a(int x);
void b(); //public abstract facultatif
}

44
 En java une classes ne peut dériver que d’une seule classe. Alors qu’elle peut implémenter
plusieurs interfaces.
 Une classe qui implémente une interface doit redéfinir toutes ses méthodes.
 Pour indiquer qu’une classe C implémente la méthode I :
public class C implements I{
//code pour redéfinir les méthodes a(int x) et b() de l’interface I
@Override
public void a(int x) {
// TODO Auto-generated method stub }
@Override
public void b() {
// TODO Auto-generated method stub }
}

45
Pour indiquer qu’une classe C implémente deux interfaces I1 et I2:

public class C implements I1, I2{

//code pour redéfinir toutes les méthodes des deux interfaces I1 et I2

46
 Comme pour les classes abstraites, une interface ne peut pas être instanciée,
Toute fois elle peut servir pour la création d’un objet qui contient une
référence vers une classe qui implémente l’interface en question. Ainsi:
 I ref ; //est correct
 I ref = new X(…) //est correct pour toute classe X qui implémente I
 Résultat: Le mécanisme d’interface permet de faire du polymorphisme avec
des objets dont les classes n’appartiennent pas à la même hiérarchie
d’héritage.

47
 Une interface peut définir aussi les constantes symboliques déclarées avec les
identificateur static et final.
Exemple:
public interface I {
static final int MAX = 10; //constante symbolique
//la déclaration des méthodes
}
 Les constantes symbolique sont partagées par toutes les classes qui
implémentent l’interface et peut être utilisée directement moyennant le nom de
l’interface.
 Exemple:
If (variable < I.MAX)……

48