PROGRAMMATION JAVA

AU : 2021 - 2022
Auditoire : 2ème Année Licence Multimédia

DR. Jihen KHALFALLAH

jihen_khalfallah@yahoo.fr
 Plan
• Concept d’héritage
• Définition d’une classe dérivée
• Exemple
• Données privées et héritage
• Constructeur et héritage
• La redéfinition des méthodes
• Le mot-clé super / final
• Les interfaces
• Les classes abstraites
• Interfaces vs classes abstraites
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 2
 PLAN DU COURS

• Chapitre 1 : Introduction à la POO

• Chapitre 2 : Syntaxe du langage Java
• Chapitre 3 : Concept de classe et objet
• Chapitre 4 : Héritage

3
PROGRAMMATION JAVA

Chapitre 4: Héritage

Auditoire : 2ème Année Licence Multimédia

DR. Jihen KHALFALLAH

jihen_khalfallah@yahoo.fr
 Principe

• L’héritage est un fondement de l’orienté objet.

• Le principe est de regrouper les mêmes caractéristiques dans

une seule classe générique

Pas de redondance de code

Facilité lors de la modification

la réutilisation du code

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 5
 Concept d’héritage
• L’un des avantages essentiel du langage JAVA est qu’on peut réutiliser un
code déjà écrit.
• Ainsi, à partir d’une définition d’une classe existante on peut définir une
nouvelle classe tout en réutilisant les attributs et les méthodes de la
classe existante : c’est le concept d’héritage.
• On dit que la nouvelle classe (appelée sous-classe) hérite de la
classe existante (appelée super-classe).
• Une sous-classe se définit par toutes les propriétés (attributs et
méthodes) de la super-classe, tout en pouvant définir de
nouvelles propriétés qui la caractérise elle seule.
• JAVA ne permet que l'héritage simple.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 6

 Vocabulaire
- La classe Animal s'appelle une classe mère, classe parente
ou super-classe
- La classe Chien qui hérite de la classe Animal s'appelle une
classe fille ou sous-classe
- Une classe qui hérite d'une autre classe (de base) s'appellle
classe dérivée

la relation: EST-UN

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 7

 Définition d’une classe dérivée
• Le mot-clé extends est utilisé pour définir une sous-
classe héritant d’une super-classe :
public class sous-classe extends super-classe{
// attributs propres à la sous-classe
// méthodes propres à la sous-classe
}
• Toutes les classes JAVA héritent par défaut d’une classe
mère Object.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 8

 Objectif de l’héritage
- Ne décrire qu'une seule fois le même traitement
lorsqu'il s'applique à plusieurs classes
- Évite de recopier (notamment les modifications)
- Pour cela,
 on crée une classe plus générique à laquelle s'applique le
traitement
 Toutes les classes plus spécifiques, héritant de cette classe,
héritent de ce traitement, et peuvent l'exécuter
 Le traitement n'est décrit qu'au niveau de la classe mère
 Les classes filles contiennent d'autres traitements plus
spécifiques
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 9
 Exemple
- Pour raccourcir les temps d’écriture et de mise au point du
code d’une application, il est intéressant de pouvoir
réutiliser du code déjà écrit
- Exemple
 La classe Voiture représente toutes sortes de voitures possibles
 On pourrait définir un camion comme une voiture très longue, très haute,
etc.
 Mais un camion a des spécificités par rapport aux voitures : remorque,
cargaison, boîte noire, etc.
 On pourrait créer une classe Camion qui ressemble à la classe Voiture
 Mais on ne veut pas réécrire tout ce qu'elles ont en commun
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 10
 Solution
• La classe Vehicule contient tout ce qu'il y a de commun à
Camion et Voiture
• Camion ne contient que ce qu'il y a de spécifique aux
camions

Vehicule

Voiture Camion

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 11

 Exemple
• Prenons l'exemple d'une classe Vehicule permettant
de décrire (de façon simple) les propriétés et les
comportements d'un véhicule du monde réel :

– Les attributs : marque, couleur, puissance moteur, vitesse

(instantanée), état (marche/arrêt).
– Les comportements : démarrer, arrêter, accélérer, freiner,
afficher les attributs...

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 12

 Exemple (suite 1/2)
• A partir de la classe Vehicule on peut, en utilisant l'héritage,
créer de nouvelles classes (Voiture et Camion) qui
spécialisent la classe Vehicule en y ajoutant de nouvelles
propriétés.
• La classe Voiture peut être caractérisée en plus des
propriétés citées dans Vehicule par un nombre de portes.
• La classe Camion peut être caractérisé en plus des propriétés
citées dans Vehicule par une charge max et un poids de
chargement, ainsi que 2 méthodes : chargement et
déchargement.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 13

 Exemple (suite2/2)
• La classe Voiture est une sous-classe de Vehicule. Elle hérite de
tous les attributs et méthodes de Vehicule en y ajoutant un attribut
(nbPortes).
• La classe Camion est aussi une sous-classe de Vehicule et hérite
de tous ses attributs et méthodes. La classe Camion y ajoute deux
nouveaux attributs (chargeMax et poidsChargement) ainsi que
deux nouvelles méthodes (charger(p) et decharger()).
• Dans les sous-classes Voiture et Camion, on peut utiliser les
attributs et les méthodes héritées (par exemple couleur ou
freiner()) comme si ces propriétés avaient été déclarés dans
chacune des sous-classes (sous réserve, que les droits d'accès le
permettent).
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 14
 Données privées et héritage
• Si un attribut est définit private dans la super-classe,
alors la sous-classe hérite cet attribut mais ne peut pas lui
accéder directement.
• Deux solutions :
– Soit changer le modificateur private de l’attribut par
protected pour permettre un accès direct dans la sous-
classe.
– Soit utiliser les méthodes get et set de cet attribut pour y
accéder en lecture ou écriture.
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 15
 Constructeur
• Le constructeur de la classe dérivée doit prendre en charge
l’intégralité de la construction de l’objet.
• Ainsi, le constructeur de la sous-classe doit initialiser les
attributs hérités (en appelant le constructeur de la super-
classe) et aussi initialiser ses propres attributs.
• L’appel du constructeur de la super-classe doit être la
première instruction dans le constructeur de la sous-classe
avec le méthode super().
Un constructeur de la classe mère est toujours exécuté avant
les autres instructions du constructeur

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 16

 Constructeur
Exemple: Ecrire les constructeurs des classes: Voiture et
Camion.
public Camion (String marque, String couleur, int puissance, int
vitesse, String etat, double chargeMax, double poidsChargement ) {
super(marque, couleur, puissance, vitesse, etat) ; // Appel
implicite de Vehicule(), avec paramètres tout dépend du
constructeur de la super-classe Vehicule
this. chargeMax = chargeMax ; // Constructeur dérivé
this.poidsChargement = poidsChargement ;
}

public Voiture (int nbPortes) {

super(); // Appel implicite de Vehicule(), sans paramètre
this. nbPortes = nbPortes ; // Constructeur dérivé }
17
 Exercice 1
- Écrire une classe Animal qui dispose d’un attribut entier
nbPattes
- Cette classe dispose des méthodes suivantes :
 le constructeur, qui prend en argument un entier (le

nombre de pattes)
 String toString(), qui renvoie une chaîne de

caractères contenant le nombre de pattes de

l’animal
 affiche() qui affiche le nombre de pattes de l’animal

- Écrire une classe Autruche qui hérite de Animal

- Écrire une classe Lapin qui hérite de Animal
- Écrire une classe Main dans laquelle la méthode main()
crée un lapin et une autruche 18
 Corrigé de l’Exercice 1
public class Animal {
private int nbPattes;
public Animal(int nbPattes){
// constructeur
setNbPattes(nbPattes);
//this.nbPattes=nbPattes;
}
// accesseur get
public int getNbPattes()
{
return nbPattes;}
// accesseur set
public void setNbPattes(int nb){
nbPattes = nb;
}
public String toString() {
return "Ceci est un animal doté de " + getNbPattes() + " pattes"; }
public void affiche(){
System.out.println(toString());}
} 19
 Corrigé de l’Exercice 1
public class Autruche extends Animal {
public Autruche(int nbPattes){
// Appel implicite d'Animal()
super(nbPattes);
// Pas de contructeur dérivé
}
public String toString() {
return "Ceci est une autruche dotée de " + getNbPattes() + " pattes";
}}

public class Lapin extends Animal {

public Lapin(int nbPattes){
// Appel implicite d'Animal()
super(nbPattes);
// Pas de contructeur dérivé
}
public String toString() {
return "Ceci est un lapin doté de " + getNbPattes() + " pattes";
20
}}
Corrigé de l’Exercice 1

public class Main {

public static void main(String[] args){
// Création d'un animal autruche
Autruche kiki = new Autruche(2);
// Création d'un animal lapin
Lapin bunny = new Lapin(4);
// Appel à la méthode Affiche() avec l'objet kiki
kiki.affiche();
// Appel à la méthode Affiche() avec l'objet bunny
bunny.affiche();
}
}

21
 Polymorphisme
• Le nom de polymorphisme vient du grec et signifie qui
peut prendre plusieurs formes.
• C’est un concept puissant de la POO qui complète
l’héritage.
• Polymorphisme de méthode: C’est la redéfinition d’une
méthode.
• Il explique comment une méthode peut se comporter
différemment suivant l’objet sur lequel elle s’applique.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 22

 La redéfinition des méthodes
• Pendant la définition de la sous-classe, on a la
possibilité de redéfinir les méthodes héritées de la super-
classe, avec le même nom et les mêmes paramètres.
• La méthode redéfinie dans la sous-classe remplace
celle définie dans la super-classe.
• Malgré cette redéfinition, il est possible de faire appel à la
méthode de la super-classe, en la préfixant par le mot-
clé super.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 23

 Le mot-clé super
• Le mot-clé super permet de désigner la super-classe.
super permet d’accéder aux attributs et méthodes de la
super-classe
• Pour manipuler un attribut de la super-classe :
Exemple : super.couleur
• Pour manipuler une méthode de la super-classe :
Exemple : super.freiner();
• Pour faire appel au constructeur de la super-classe:
Exemple : super(nbPortes);
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 24
 Le mot-clé final
• Dans la déclaration d'une classe, le modificateur final
indique que la classe ne peut pas être sous-classée (on ne peut
pas hériter de cette classe).
• Dans la déclaration d'un attribut, le modificateur final
indique que la valeur du champ ne peut pas être modifiée après
l'affectation initiale. Ça Permet de définir des valeurs
constantes.
• Dans la déclaration d'une méthode, le modificateur final
indique que la méthode ne peut pas être redéfinie dans une
sous-classe.
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 25
 Héritage multiple
• Une des notions les plus délicate à manipuler en orientée
objet est l'héritage multiple.
• Java ne dispose pas de l'héritage multiple comme en C++
par exemple.
• Une classe ne peut avoir qu'une seule classe mère.
• Java dispose en revanche de la notion d'interface qui offre
des possibilités proches de celles de l'héritage multiple.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 26

 Interfaces et classes abstraites
• Si on veut imposer un modèle (prototype) bien définie
pour des classes de données (càd des classes qui
contiennent obligatoirement la définition de certaines
méthodes), on peut utiliser soit :

– Des interfaces
– Des classes abstraites

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 27

 Les interfaces : Définition
• Une interface est un prototype de classe. Elle contient
uniquement la signature (entête) des méthodes qui doivent être
implémentées (développer leur code) dans les classes construites
à partir de cette interface.
• La définition d’une interface se présente comme celle d’une
classe, mais en utilisant le mot-clé interface à la place de
class.
• Une interface n’a pas de constructeur et ne peut pas être
instancié.
• Une interface définie est implémentée par des classes de
données.
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 28
 Les interfaces Syntaxe
Exemple 1 :
public interface Comparable {
boolean coincide (Point p);
}

Exemple 2 :
public interface Conduire {
void demarrer();
void arreter();
void accelerer(int x);
void freiner(int x);
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 29
Implémentation d’une interface
• Dans la classe, le mot-clé implements indique le nom de
l’interface implémentée.
public class Point implements Comparable{
private double x, y;
// getters setters et constructeur. . .
public boolean coincide (Point p) {
if(this.x == p.getX() && this.y == p.getY())
return true;
else
return false;
}}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 30
 Implémentation de plusieurs interfaces
• Une classe peut hériter d’une autre classe et implémenter une
interface :

class Voiture extends Vehicule implements Conduire {

...
}

• Une classe peut implémenter plusieurs interfaces :

class grenouille implements surTerre, dansEau {
...
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 31
 Classes abstraites
• Une classe abstraite contient au moins une signature d’une
méthode abstraite.
• Elle doit être explicitement précisé dans la déclaration de la classe
avec : public abstract class
• Les classes abstraites ne peuvent pas être instanciées.
• Une classe abstraite peut contenir des méthodes concrètes
(avec définition) à part les méthodes abstraites.
• Une méthode abstraite n'a pas de corps, elle est constituée simplement
d'une signature suivie d'un ;
• Une méthode abstraite à la forme :
public abstract type nom_methode(type_param nom_param, …);
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 32
 Classes abstraites : exemple
• Considérons la hiérarchie des classes suivantes :

• On veut que toutes les sous-classes (Cercle et

Rectangle) disposent de la méthode aire()retournant
l’aire de la figure géométrique définie par la classe Figure.
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 33
 Classes abstraites : exemple
public abstract class Figure {
// Définition de la classe de base comme étant abstraite
private String nom; //attribut
public Figure (String nom) { // Contructeur d’une classe de base
this.nom=nom;
}
// Voilà la méthode "abstraite" :
public abstract double aire();
// Toutes les méthodes ne sont pas abstraites "méthodes concrètes"
public void affiche() {
System.out.println("Je suis un "+ this.nom) ;
}}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 34
 Classes abstraites : exemple
public class Cercle extends Figure {
// Définition d'une sous-classe de Forme

private double rayon ;

// Définition des attributs propres aux cercles
public Cercle(String nom, double rayon) {
super(nom); // Appel implicite de Forme(), avec paramètre

this.rayon = rayon ; // Constructeur dérivé

}
public double aire(){
return Math.PI*rayon*rayon ;
// Redéfinition(overriding) des méthodes abstraites héritées de Forme

}} 35
 Classes abstraites : exemple
public class Rectangle extends Figure {
// Définition d'une autre sous-classe de Forme
private double largeur ;
private double longueur ;
// Définition des attributs propres aux rectangles
public Rectangle (String nom, double largeur, double longueur)
{
super(nom); // Appel implicite de Forme(), avec paramètre
this.largeur = largeur ;
this.longueur = longueur ; // Constructeur dérivé
}
public double aire(){
return this.largeur*this.longueur;
// Redéfinition (overriding) des méthodes abstraites
héritées de Forme
36
}}
Interfaces vs classes abstraites
Interface
Il est préférable d’utiliser
l’interface lorsque plusieurs
implémentations partagent
uniquement la signature de
méthode.
Lorsqu’on connait que les
exigences et non les
implémentations, utilisez une
« Interface ».
 Rappel
- Signature d’une méthode (nom de la méthode + ensemble des types
de ses paramètres)
Classe abstraite
Elle doit être utilisée lorsque
différentes implémentations
du même type partagent un
comportement commun (la
définition d’une méthode).
Lorsqu’on connait
partiellement les
implémentations, utilisez une
« classe abstraite ».
37