PROGRAMMATION OBJET EN

JAVA

Dr Fatou KAMARA-SANGARE
UFR de Sciences Appliquées et de Technologie
Université Gaston Berger de Saint-Louis
 Chapitre 1II
Mise en œuvre de l’héritage en java
Héritage
Rappels
L’héritage est un mécanisme de transmission des propriétés d’une classe vers une
classe.

Il permet de définir une classe comme l’extension d’une autre

L’héritage implique une classe de base et une classe dérivée. La classe dérivée hérite
de la classe de base et apporte ses propres spécificités.

La classe C2 (sous-classe) hérite de la classe C1 (super-classe), alors C2 hérite de

toutes les fonctionnalités de sa classe de base. Elle peut avoir des caractéristiques
propres et redéfinir des caractéristiques héritées.

Héritage=définir une classe dérivée (nouvelle classe) d’une classe de base (classe
existante).
Héritage
Avantages
L’héritage est un mécanisme de partage de code qui permet de :
▪ éviter la duplication de code ;
▪ réutiliser du code dans un autre contexte ;
▪ faciliter la maintenance des programmes.

Mise en œuvre de l’héritage en java

Toute classe Java est une sous-classe de la classe « java.lang.Object»

Java ne permet pas l’héritage multiple

Pour présenter le mécanisme d’héritage en java, le programmeur

doit définir au moins deux classes :
▪ une classe mère « ClasseMere »
▪ une classe fille « ClasseFille »
Héritage
Exemple d’application
Pour la gestion d'une bibliothèque on demande d'écrire une application
manipulant des documents de nature diverse : des livres, des dictionnaires, etc.
Tous les documents ont un numéro d'enregistrement et un titre. Les livres ont, en
plus, un auteur et un nombre de pages, les dictionnaires ont une langue et un
nombre d'articles.
Partie interne de la classe Document
On identifie trois classes :
▪ Document ; Attribut Type Visibilité
▪ Livre ; numeroEnregistrement int protégé
▪ Dictionnaire. titre String protégé

Partie interne de la classe Livre Partie interne de la classe Dictionnaire

Attribut Type Visibilité Attibut Type Visibilité
nomAuteur String privé langue String privé
nombreDePages int privé nombreDArticles int privé
Héritage
Mise en œuvre des trois classes
class Document { protected String titre; protected int numeroEnregistrement ;}

class Livre extends Document {private String auteur; private int nombreDePages;}

class Dictionnaire extends Document { private String langue ; private int nombreDArticles;}

Le mot clé extends est uitilisé pour signaler au compilateur que les classes Livre et
Dictionnaire dérivent de la classe Document.
classe nom_classefille extends nom_classemere {}
Héritage
Constructeur d’une classe dérivée
Pour initialiser les attributs hérités, un constructeur d’une classe dérivée peut invoquer
un des constructeurs de la classe mère en utilisant le mot-clé super.

L’appel d’un constructeur de la classe mère doit être la première instruction du

constructeur de la classe fille.

class Document {
protected String titre;
protected int numeroEnregistrement;public
Document(int numeroEnregistrement, String titre) {
this.numeroEnregistrement = numeroEnregistrement;
this.titre = titre;}}
Héritage
Constructeur d’une classe dérivée
class Livre extends Document {
private String auteur;
private int nombreDePages;
public Livre(int numeroEnregistrement, String titre, String auteur, int nombreDePages)
{// appel au constructeur de la classe de base
super(numeroEnregistrement, titre);
this.auteur = auteur;
this.nombreDePages = nombreDePages;}}

class Dictionnaire extends Document

{ private String langue ;
private int nombreDArticles;
public Dictionnaire(int numeroEnregistrement, String titre, String langue, int nombreDArticlesArticles)
{ // appel au constructeur de la classe de base
super(numeroEnregistrement, titre);
this.langue = langue;
this.nombreDArticlesArticles= nombreDArticlesArticles;}}
this.nombreDePages = nombreDePages;}}
Héritage
Accès d’une classe dérivée aux membres de sa classe mère
Une classe dérivée peut accéder aux membres publics et/ou protégés de sa classe de base. Elle
se fait avec le mot clé super.

Une classe dérivée n’accède pas aux attributs privés de sa classe de base. Il faut utiliser les getters
et setters (getNomAttribut et setNomAttribut).

Mot clé super

super permet à une classe d’accéder aux attributs et méthodes de sa classe mère comme suit :
super.nomAttribut; super.nomMéthode([liste des arguments effectifs])

Dans le cas d’un héritage de plusieurs niveaux, l’accès des membres des classes mères se fait à un
niveau supérieur. L’instruction suivante est incorrecte : super.super.m() ;

Autrement dit, l’appel par super ne concerne que le constructeur de la classe de base de niveau
immédiatement supérieur (vu qu’une classe peut dériver d’une classe qui aussi dérive d’une autre
Héritage
Mot clé super
Possibilité d’appeler dans un constructeur un autre constructeur de la même classe, en utilisant
le mot clé this comme nom de méthode comme première instruction du constructeur appelant.

Possibilité d’appeler un constructeur mère en utilisant le mot clé super comme méthode. Cet
appel doit correspondre à la première instruction du constructeur.

Autrement dit, dans un constructeur d’une classe dérivée, il n’est pas possible d’appeler en même
temps un constructeur de la même classe et un constructeur d’une classe de base.

Exemple

public class A extends B {

public A( i n t x )
{ super ( ) ;
t hi s ( ) ; } }
Héritage

this vs super
this super
fait référence à l’objet courant fait référence à la classe parente
invoque un constructeur de la même classe fait appel à un constructeur de la classe de base
différencie les attributs d’une classe des permet à une classe dérivée d’accéder aux
variables locales (des arguments, variables attributs et méthodes de sa classe mère
locales utilisés dans une méthode
Héritage
Redéfinition d’une méthode
La signature d’une méthode est l’ensemble composé de :
▪ du nom de la méthode
▪ types des paramètres

Signature de méthode = (nom méthode + types des paramètres)

Elle permet d’identifier de manière unique une méthode dans une classe.

La redéfinition d’une méthode est la possibilité de donner une nouvelle implémentation

à une méthode héritée sans changer sa signature et le type de retour.

Pour redéfinir :
1. la méthode est définie dans une classe de base ;
2. une nouvelle définition de la méthode est proposée dans la classe dérivée ;
3. La signature de la méthode définie dans la classe dérivée est identique à celle
définie dans la classe de base.
Héritage
Redéfinition d’une méthode
Ajoutez une méthode description(), définie dans la classe Document et redéfinie dans
les classes Livre et Dictionnaire qui renvoie une chaîne de caractères qui est affiche la
fiche d'un document.
class Document {
protected String titre; protected int numeroEnregistrement;
public Document(int numeroEnregistrement, String titre) {
this.numeroEnregistrement = numeroEnregistrement;
this.titre = titre;}
//redéfinition de la méthode toString de la classe object
public String toString()
{return "titre : "+titre+"\n"+"numéro d'enregistre : "+numeroEnregistrement;}
public void description(){System.out.println(toString());}}
Héritage
Redéfinition d’une méthode
class Livre extends Document {
private String auteur;
private int nombreDePages;
public Livre(int numeroEnregistrement, String titre, String auteur, int nombreDePages) {
// appel au constructeur de la classe de base
super(numeroEnregistrement, titre);
this.auteur = auteur;
this.nombreDePages = nombreDePages;}

// Redéfinition de la méthode description

public void description(){
//Appel de la méthode description de la classe de base
super.description();
System.out.println("Le nombre de pages : "+nombreDePages+"\n"+"Auteur :
"+auteur);}}
Héritage
Redéfinition d’une méthode
La redéfinition d’une méthode ne doit pas diminuer les droits d’accès à cette méthode.
Elle peut les augmenter.

Classe mère Classe dérivée

class Document {
....................................................
....................................................
public void description(){System.out.println(toString());}}
class Livre extends Document {
....................................................
....................................................
// Redéfinition description
private void description() [IMPOSSIBLE]{
....................................................
....................................................}}
Droit d’accès diminuer dans cet exemple
Héritage
Redéfinition d’une méthode

Classe mère Classe dérivée

class Document {
....................................................
....................................................
protected void description(){System.out.println(toString());}}
class Livre extends Document {
....................................................
....................................................
// Redéfinition description
public void description() [POSSIBLE]{
....................................................
....................................................}}
Droit d’accès augmenté dans cet exemple
Héritage
Surdéfinition (surcharge) d’une méthode
On appelle surcharge (en anglais « overloading ») d’une méthode, la possibilité de
définir des comportements différents pour la même méthode. La surcharge concerne
au moins deux méthodes de même nom mais avec des signatures différentes.
Classe mère
class Document {
...................................................
....................................................
//redéfinition de la méthode toString
public String toString()
{return "titre : "+titre+"\n"+"numéro d'enregistre : "+numeroEnregistrement;}
public void description(){System.out.println(toString());}

//méthodes avec surchargées

public void ModifierAttributs(String titre, int n){this.titre=titre; numeroEnregistrement=n;}

public void ModifierAttributs(String titre){this.titre=titre;}

public void ModifierAttributs(int n){numeroEnregistrement=n;}}

Héritage
Redéfinition et Surdéfinition
Surcharge Redéfinition
Héritage Pas nécessaire Nécessite une arborescence de classes
Signatures des méthodes Signature différente Mêmes signature
Résolution à Compilation Exécution

Remarques
▪ Une classe définie avec le mot clé final ne peut pas disposer de sous-classe

▪ Une méthode déclarée finale ne peut être redéfinies dans les sous-classes

▪ Une méthode de classe (static) ne peut pas être redéfinie dans une classe
dérivée.
Polymorphisme
Définition
En programmation Objet, on appelle polymorphisme le fait que :
▪ un objet d’une classe puisse être manipulé comme s’il appartenait à une
autre classe ;

▪ la même opération puisse se comporter différemment sur différentes

classes de la hiérarchie.

Le polymorphisme peut être vu comme la capacité de choisir dynamiquement la

méthode qui correspond au type réel de l’objet.

Si la classe B hérite de la classe A

▪ Classe B "EST-UN" Classe A
▪ toute méthode m de A peut-être invoquée par une instance de la classe B
Polymorphisme
Définition

Le polymorphisme est la capacité, pour un même message de correspondre à

plusieurs formes de traitements selon l’objet auquel ce message est adressé. La
gestion du polymorphisme est assurée par la machine virtuelle dynamiquement à
l'exécution.
Polymorphisme
Définition

Document
titre
numeroEnregistrement
afficher
description

Livre Dictionnaire
auteur langue
nombredePages NombreDeArticles
afficher afficher
description description

Roman
PrixLittéraire
afficher
description
Polymorphisme
Définition

Un livre est un document

Document doc=new Livre([Liste effectifs arguments ])

Un dictionnaire est un document

Document doc=new Dictionnaire([Liste effectifs arguments ])

Un livre n’est pas nécessairement un document

Livre =doc
Choix de la méthode : liaison dynamique
Le type statique d’une variable, est celui donné à sa déclaration :
Document unDocument = new Livre (arguments effectifs)

Document est le type déclaré.

Le type dynamique d’une variable, est celui de la classe utilisée pour

construire l’objet référencé par la variable à un point précis de l’exécution.
Document unDocument = new Livre (arguments effectifs)

Livre est le type dynamique.

Le type dynamique d’un objet est le type de l’objet instancié (type réel).
Choix de la méthode : liaison dynamique
Liaison dynamique ≈ répond à la question: «quel code est exécuté ?»

La méthode à exécuter est déterminée à l’exécution et non pas à la compilation.

La méthode définie pour le type réel de l’objet recevant le message est appelée
et non pas celle définie pour son type déclaré.

A la compilation :
▪ seules des vérifications statiques qui se basent sur le type déclaré de
l’objet (de la référence) sont effectuées.

▪ il n’est pas possible de déterminer le type exact (réel) de l’objet

récepteur du message.
Choix de la méthode : liaison dynamique
Le choix de la méthode à exécuter est effectuée statiquement à la compilation
en fonction du type des paramètres.

Vérification permet de déterminer simplement la signature et le type de la

valeur de retour de la méthode qui sera exécutée.

La sélection du code à exécuter est effectuée dynamiquement à l’exécution en

fonction du type effectif de l’objet récepteur du message.
 Liaison dynamique

Document
titre
numeroEnregistrement
afficher
description

Livre Dictionnaire
auteur langue
nombredePages NombreDeArticles
afficher afficher
description description

Roman
PrixLittéraire
afficher
description
Choix de la méthode : liaison dynamique
Roman unRoman=new Roman(arg)
Roman.afficher()
Le principe de l’exécution est la suivante
Si la méthode afficher existe dans la classe Roman alors
Elle est exécutée
Sinon
la méthode est rechercher dans sa classe de base

La méthode existe dans les quatre classes , alors la méthode définie dans la classe
Roman sera exécutée

La méthode est définie dans les classes Document,, Livre et Dictionnaire, alors la
méthode afficher de la classe Livre sera exécutée

La méthode est définie dans les classes Document et Dictionnaire, alors la méthode
de la classe Document sera exécutée
 Polymorphisme
La méthode description a quatre codes différents. En d’autres termes description a plusieurs
formes de codes différents : c’est le polymorphisme.

Document doc=new Document([liste effectifs des arguments effectifs])

doc.description // lance la méthode description de la classe Document

Livre unLivre = new Livre([Liste effectifs arguments ])

unLivre.description(); // lance la méthode description de la classe Livre

Roman unRoman = new Roman ([Liste effectifs arguments ])

unRoman.description(); // lance la méthode description de la classe Roman

Document doc=new Livre([liste effectifs des arguments effectifs])

doc.description // lance la méthode description de la classe Livre
Choix de la méthode : liaison dynamique
Exercice renseigner le tableau ci-dessous en fonction des affirmation suivantes :
▪ Connu à la compilation
▪ Peut changer pendant l’exécution
▪ Est un sous type du type statique
▪ Ne change pas pendant l’exécution

Type statique vs type dynamique

Type statique Type dynamique
Classe abstraites
Méthode abstraite
Une méthode abstraite est une méthode déclarée et non définie dont le
modificateur abstract est utilisé.

Syntaxe d’une méthode abstraite

abstract nomMethode([Liste des arguments formels]);

▪ Une méthode abstraite ne doit pas être private.

▪ Une méthode abstraite ne doit pas être déclarée final car elle doit
être redéfinie dans une sous-classe.

▪ Une méthode abstraite ne doit jamais pas être déclarée static.

Classe abstraites
Classe abstraite
Une classe abstraite est une classe incomplète qui contient au moins une méthode
abstraite.

On définit une classe abstraite en Java en utilisant le mot clé abstract devant le nom de la classe

Syntaxe d’une classe abstraite

abstract class NomDeLaClasse {

/* déclaration d’attributs
déclaration de constantes
*/
// Définitions de méthodes

/*DECLARER AU MOINS UNE METHODE

méthode(s) déclarée(s) (méthode (s) non définie(s))
*/}
Classe abstraites
Exemple
Une forme géométrique dans le plan peut être un cercle, un rectangle, etc. Une
forme géométrique peut être évaluée en fonction de son périmètre et de sa surface.
Un cercle est identifié par son centre et son rayon. Un rectangle par son largeur et sa
longueur. Le rayon d’un cercle est la distante du centre et d’un point du cercle.

Quatre classes ont été identifiées

Point Classe concrète Décrit un point du plan
Lesformesgeometriques Classe abstraite classe abstraite ou les méthodes perimetre et
surface sont déclarées
Cercle Classe concrète Elle définit les méthodes perimetre et surface
Rectangle Classe concrète Elle définit les méthodes perimetre et surface
 Classes abstraites
Caractéristiques d’une classe abstraite
Une classe abstraite est une classe ayant au moins une méthode abstraite.

Une classe abstraite ne peut pas être instanciée (new).

Une classe abstraite ne peut pas être final

Sous-classe d’une classe abstraite peut :

implémenter toutes les méthodes abstraites de sa superclasse : une classe concrète

ne pas implémenter toutes les méthodes abstraites : abstraite
 Classes abstraites
Implémenter les classes : Point, LesFormesGéometrique, Rectangle, Cercle
 Classes abstraites

Exemple
Une forme géométrique dans le plan peut être un cercle, un rectangle,
etc. Une forme géométrique peut être évaluée en fonction de son
périmètre et de sa surface. Un cercle est identifié par son centre et son
rayon. Un rectangle par sa largeur et sa longueur. Le rayon d’un cercle
est la distante du centre et d’un point du cercle

Quatre classes ont été identifiées

Point Classe concrète Décrit un point du plan
Lesformesgeometriques Classe abstraite classe abstraite ou les méthodes perimetre et
surface sont déclarées
Cercle Classe concrète Elle définit les méthodes perimetre et surface
Rectangle Classe concrète Elle définit les méthodes perimetre et surface
 Classes abstraites
package lesformesgeometriques;

class Point { private double x; private double y ;

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

public void afficherPoint()

{System.out.println("( "+x+" , "+y+" )" );}

public double getX() {return x;}

public void setX(double x) {this.x = x;}
public double getY() {return y;}
public void setY(double y) {this.y = y;}

public double distance(Point p)

{return Math.sqrt(( (this.x-p.x)*(this.x-p.x))
+(this.y-p.y)*(this.y-p.y));}}
package lesformesgeometriques;
abstract class Formesgeometriques {

//Déclaration des attributs

protected Point p; protected Point q; protected double rayon;
protected double largeur; protected double longueur;

//Définition des constructeurs

public Formesgeometriques(Point p, Point q, int rayon) {
this.p = new Point(p.getX(),p.getY());
this.q = new Point(q.getX(),q.getY());
this.rayon = p.distance(q);}
public Formesgeometriques(double largeur, double longueur) {
this.largeur = largeur; this.longueur = longueur;}

//Définition d’une méthode concrète

void afficherUneForme()
{System.out.println("Son perimetre est :"+perimetre() );
System.out.println("Sa surface st : "+ surface());}

//déclaration de méthodes abstraites

abstract double perimetre();
abstract double surface();}
package lesformesgeometriques; package lesformesgeometriques;

class Rectangle extends Formesgeometriques {

//Définition du constructeur
Rectangle(int largeur, int longueur) {super(largeur,longueur);}

//Définition des méthodes

public void afficherUneForme(){
System.out.println("Les information sur le rectangle sont : ");
System.out.println("Longueur : "+ longueur);
System.out.println("Largeur: "+ largeur);
super.afficherUneForme();
System.out.println("\n\n");}

//Méthode perimetre et surfacs sont des méthodes concrétes

double perimetre() {return (largeur+longueur)*2;}
double surface() {return largeur*longueur;}}
package lesformesgeometriques;

class Cercle extends Formesgeometriques {

//Définition du constructeur
public Cercle(Point p, Point q) {super(p, q);}

//Définition des méthodes

public void afficherUneForme(){
System.out.println("Les information sur le cercle sont : ");
System.out.println("Centre : "+ p);
System.out.println("Rayon: "+ rayon);
super.afficherUneForme();
System.out.println("\n\n");}

//Méthode perimetre et surfacs sont des méthodes concrétes

double perimetre() {return 2* Math.PI*rayon;}
double surface() {return Math.PI*rayon*rayon;}}
 Classes abstraites
Caractéristiques d’une classe abstraite
Une classe abstraite est une classe ayant au moins une méthode
abstraite.

Une classe abstraite ne peut pas être instanciée (new).

Une classe abstraite ne peut pas être final

Sous-classe d’une classe abstraite peut :

implémenter toutes les méthodes abstraites de sa superclasse.
elle pourra alors être déclarée comme une classe
concrète
ne pas implémenter toutes les méthodes abstraites.
elle reste alors abstraite ajouter
Interfaces
 Interfaces
Définition
Une interface est une classe ou tous les membres sont soit des constantes ou des
méthodes abstraites

La mise en œuvre d’une interface en java

Pour définir une interface en java, il faut utiliser le mot clé interface
et non le mot clé class

Syntaxe d’une interface

interface NomDeLinterface {
//déclaration de constantes

// Déclaration des méthodes abstraites

//PAS DE METHODE CONCRETE

}
 Interfaces
Elle a que de
constantes

Interface =classe
Toutes les méthodes
sont abstraites

Une classe peut implémenter une ou plusieurs interfaces mais elle

peut en héritée une et seule classe

Si une classe implémente une interface, il faut obligatoirement

redéfinir toutes les méthodes de l’interface

Aucune définition de méthode ne peut être différée comme dans le

cas des classes abstraites.
package lesformesgeometriques;

public interface MesFormesGeometriques {

abstract double perimetre();
abstract double surface();
abstract public void Afficher();}
package lesformesgeometriques;
class UnCercle implements MesFormesGeometriques {
//Déclaration des attributs
double rayon; Point centre;

//Définition du constructeur
public UnCercle(Point centre, double rayon) {
this.centre = new Point (centre.getX(),centre.getY());
this.rayon = rayon;}

//Définition des méthodes de l’interface

public double perimetre() {return 2*Math.PI*rayon;}

public double surface() {return Math.PI*rayon*rayon;}

public void Afficher(){

System.out.println("Les information sur le cercle sont : ");
System.out.print("Centre : ("+ centre.getX()+ ",” );
System.out.println(centre.getY()+")" );
System.out.println("Rayon: "+ rayon);
System.out.println("Son perimetre est :"+perimetre());
System.out.println("Sa surface st : "+ surface());
System.out.println("\n\n");}}
package lesformesgeometriques;

public class UnRectangle implements MesFormesGeometriques {

//Déclaration des attributs
double largeur; double longueur;

//Définition du constructeur
public UnRectangle(double largeur, double longueur) {
this.largeur = largeur; this.longueur = longueur;}

//Définition des méthodes de l’interface

public void Afficher() {
System.out.println("Les information sur le rectangle : ");
System.out.println("Longueur : "+ longueur);
System.out.println("Largeur: "+ largeur);
System.out.println("Son perimetre est :"+perimetre() );
System.out.println("Sa surface st : "+ surface());
System.out.println("\n\n");}

public double perimetre() {return (largeur+longueur)/2;}

public double surface() {return largeur*longueur;}}
 Interfaces
Dans la définition d’une interface seuls les droits d’accès public et de paquetage sont
autorisés.

Une interface peut hériter (extends) de plusieurs interfaces.

Une interface peut étendre une ou plusieurs d'une interface a la

fois.

Si est une interface hérite d’une autre interface alors

▪ hérite de toutes les méthodes abstraites et des constantes de
l’interface de base

▪ peut définir de nouvelles constantes et méthodes abstraites.