L’héritage en

Rajae El Ouazzani

2017-2018
Plan:
 Section 1: L’héritage
 Présentation
 Exemple
 Les modificateurs d’accès
 L’opérateur instanceof
 Section 2: Les classes abstraites
 Présentation
 Exemple

2017-2018
Section 1: L’héritage

2017-2018
Présentation
Personne
Etudiant
nom
nom prenom
prenom age
age
toString()
cne
toString()

Etudiant Enseignant
Enseignant
cne ppr
nom grade
prenom
age
ppr
grade
toString()
2017-2018
Explication [1]
 Les classes Etudiant et Enseignant ont plusieurs similitudes.
 Un des avantages de la POO est la possibilité de gérer de telles
similitudes, comme dans une hiérarchie. Cette possibilité s’appelle
héritage.
 Quand une classe hérite d’une autre classe, la classe enfant hérite
automatiquement de toutes les caractéristiques (variables membres)
et du comportement (méthodes) de la classe mère. L’héritage est
toujours additif; il n’est pas possible d’hériter d’une classe et de
recevoir moins que ce que possède la classe mère.
 En Java, l’héritage est géré avec le mot clé extends. Quand une
classe hérite d’une autre classe, la classe fille étend la classe mère.

2017-2018
Prototypes de 3 classes
public class Personne{
...
}

public class Etudiant extends Personne{

...
}

public class Enseignant extends Personne{

...
}
2017-2018
Déclarations
 On crée la classe Personne pour gérer les similitudes entre les
classes Etudiant et Enseignant.
 Ensuite, on supprime les déclarations des éléments communs
lors de la déclaration des sous-classes Etudiant et Enseignant.

2017-2018
 Personne
nom
prenom
age
Personne()
Personne(nom, prenom, age)
String toString()

Etudiant Enseignant
cne ppr
grade
Etudiant()
Etudiant(nom, prenom, age, cne) Enseignant()
String toString() Enseignant(nom, prenom, age, ppr, grade)
String toString()

2017-2018
 La classe Personne
class Personne {
String nom, prenom;
int age;
// constructeur par défaut
public Personne() {
nom = "Lazraq";
prenom= "Mohammed";
age = 20;
}
//constructeur avec paramètres
public Personne(String nom, String prenom, int age){
this.nom = nom;
this.prenom= prenom;
this.age = age;
} 2017-2018
String getNom(){
return nom;
}
String getPrenom(){
return prenom;
}
int getAge(){
return age;
}

public String toString(){

return getNom()+" "+getPrenom()+" est agé de "+
getAge()+ " ans.";
}
}

2017-2018
 La classe Etudiant
public class Etudiant extends Personne{
long cne;
public Etudiant() {
super(); // appel du constructeur par défaut de la classe mère
cne= 123654789;
}
public Etudiant(String nom, String prenom, int age, long cne){
// appel du constructeur avec param de la classe mère
super(nom, prenom, age);
this.cne= cne;
}
long getcne(){
return cne;
}
}

2017-2018
 La méthode toString()
 Le polymorphisme est la possibilité pour deux classes séparées, mais
reliées, d’avoir la même méthode mais l’implémenter de façon différente.
 Le mot clé super permettra d’accéder à toutes les méthodes ou variables
membre de la classe de niveau supérieur.

 Nous ajoutons le code suivant à la classe Etudiant:

public String toString(){
return super.toString()+"C'est un étudiant de cne: " +getcne();
}

2017-2018
Appel dans le programme principal
public static void main(String[] args){
Etudiant E1 = new Etudiant("Lotfi","Karim", 22, 1472585);
Etudiant E2 = new Etudiant();
System.out.println(E1.toString());
System.out.println(E2.toString());
}

Résultat:
Lotfi Karim est agé de 22 ans. C'est un étudiant de cne: 1472585
Lazraq Mohammed est agé de 20 ans. C'est un étudiant de cne:
123654789

2017-2018
Exemple [http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-en-java/l-
heritage-1]
//Définition d'un tableau de villes null
Personne[] tableau = new Personne[6];
//Définition d'un tableau de noms de personnes et un autre de leurs ages
String[] tab1 = {"Lmarss", "Latfi", "Maaroufi", "Yassini", "Allali"};
int[] tab2 = {22, 21, 22, 21, 21,};
//Les trois premiers éléments du tableau seront des personnes, et le reste, leurs ages
for(int i = 0; i < tab1.length; i++){
if (i <3){
Ville V = new Ville(tab[i], tab2[i], "france");
tableau[i] = V;
}
else{
Capitale C = new Capitale(tab[i], tab2[i], "france", "la tour Eiffel");
tableau[i] = C;
}
}
//Il ne nous reste plus qu'à décrire tout notre tableau !
for(Ville V : tableau){
System.out.println(V.decrisToi()+"\n");
}

2017-2018
Les modificateurs d'accès [1]
 A l'intérieur d'une classe, on peut accéder à tous les attributs et les
méthodes directement par leur nom (accès direct).

class Personne{ Tous les attributs et méthodes

private String nom, prénom;
private int âge;
protected String getnom(){….}
protected String getprénom(){….}
protected int getâge(){….}
String toString(){…}
public static void main(){…}
}
sont accessibles directement à
l’intérieur de la classe Personne.
Il suffit d’utiliser le nom de
l’attribut ou celui de la méthode.
Exemple:
nom, getnom(), toString(), etc.

2017-2018
 Suite
 L'accès aux attributs et aux méthodes à l'extérieur des classes Java
dépend des modificateurs d'accès. Ces modificateurs définissent
divers degrés d'accès aux membres des classes.
 Les modificateurs d'accès sont indiqués juste avant le type de la
variable ou de résultat pour les méthodes.
 Exemples :
public String nom;
protected String prénom;
private int âge;
String toString()

2017-2018
 Suite
 Il existe quatre modificateurs d'accès:
 par défaut (il n'y a pas de modificateur): seules les classes de même
paquetage peuvent accéder aux données membres.
 public: les membres sont accessibles à tous, que ce soit de
l'intérieur ou de l'extérieur de la classe ou du paquetage:
 protected: les membres ne sont accessibles qu'aux méthodes dans
cette classe et dans les classes dérivées de cette classe ou du
paquetage.
 private: les membres ne sont accessibles qu'aux méthodes dans la
classe où ils ont été définis (accès direct).
 Remarque: En règle générale, il vaut mieux limiter la portée des
éléments des programmes (dont les membres des classes) autant que
possible; moins un élément est accessible, moins il risque d’être mal
2017-2018
utilisé.
 Niveaux d’accès [1]
Accès depuis l’intérieur du paquet d’une classe
Modificateur d’accès Héritage Accessible
Par défaut (pas de modificateur) Oui Oui
public Oui Oui
protected Oui Oui
private Non Non

 Ce tableau montre comment les autres membres du même paquet

accèdent aux membres d’une classe et en héritent.
 Par exemple, un membre déclaré private est inaccessible depuis les
autres membres du même paquet et il est impossible d’en hériter.
 Les membres déclarés avec les autres modificateurs sont accessibles
depuis les autres membres de ce paquet qui peuvent aussi en hériter.
2017-2018
 Exemple
Paquet Package1

class Voiture{
class Personne{ …
private String nom, prénom; getnom(), getprénom(), getâge() : protected
private int âge; toString(): par défaut
protected String getnom(){….} main(): public
protected String getprénom(){….} }
protected int getâge(){….}
String toString(){…} class Etudiant extends Personne{
public static void main(){…} …
} getnom(), getprénom(), getâge() : protected
toString(): par défaut
main(): public
}

2017-2018
Niveaux d’accès (Suite)
Accès depuis l’extérieur du paquet d’une classe
Modificateur d’accès Héritage Accessible
Par défaut (pas de modificateur) Non Non
public Oui Oui
protected Oui Non
private Non Non

 Ce tableau montre qu’il est possible d’hériter d’un membre de

type protected mais qu’il est impossible d’y accéder à partir de
classes situées en dehors de son paquet.

2017-2018
 Exemple
Paquet Package1 Paquet Package2

class Voiture{
class Personne{ …
private String nom, prénom; main(): public
private int âge; }
protected String getnom(){….}
protected String getprénom(){….}
protected int getâge(){….}
String toString(){…} class Etudiant extends Personne{
public static void main(){…} …
} getnom(), getprénom(), getâge() : protected
main(): public
}

2017-2018
 L’opérateur instanceof [2]
 instanceof permet de savoir la classe à laquelle une instance (un objet) appartient.
Soit le cas de figure suivant: B

class B{ …} C
class D extends B{…}
class C {…}
D
B b = new B();
D d = new D();
C c = new C();

Groupe 1 d’instructions: Groupe 2 d’instructions:

b instanceof B // true b = d; // si on ajoute b=d
b instanceof D // false b instanceof B // true
d instanceof B // true b instanceof D // true
d instanceof D // true c instanceof B /* erreur de compilation:
Les types C and B sont incompatibles. */
2017-2018
 Exemple
 Vérification des objets qui appartiennent à la classe Personne.
class Personne {
private String nom, prenom;
private int age;
// constructeur par défaut
public Personne() {
nom = "Lazraq";
prenom= "Mohammed";
age = 20;}
//constructeur avec paramètres
public Personne(String nom, String prenom, int age) {
this.nom = nom;
this.prenom= prenom;
this.age = age;}
public String getNom(){ return nom; }
public String getPrenom(){ return prenom; }
public int getAge(){ return age; }
public String toString(){
return getNom()+" "+getPrenom()+" est agé de "+getAge()+ " ans.";
} 2017-2018
public static void main(String[] args){
Personne p1=new Personne("Lotfi","Karim", 22);
Personne p2=new Personne("Lotfi","Karim", 22);
System.out.println(p1.toString());
System.out.println(p2.toString());
System.out.println("p2 est une instance de Personne: "+ (p2 instanceof Personne));
System.out.println("p1.equals(p2): "+p1.equals(p2));
}
}
Résultat:
Lotfi Karim est agé de 22 ans.
Lotfi Karim est agé de 22 ans.
p2 est une instance de Personne: true
p1.equals(p2): false

Remarque: L’implémentation par défaut de la méthode equals(Object) est:

public boolean equals(Object obj) {
return (this == obj); // comparaison des identités
}
Pour que p1.equals(p2) donne un résultat2017-2018
true, il faut redéfinir la méthode equals(Object).
Redéfinition de equals(Object obj) [3]
 La méthode equals(Object obj) qui compare 2 objets utilise dans son code
l’opérateur instanceof.

public boolean equals(Object obj) {

if ( this == obj ) return true; // avoir la même identité
if ( !(obj instanceof Personne)) return false;
Personne p=(Personne)obj; // cast sur obj
return (nom==p.nom && prenom==p.prenom && age==p.age);
}
 Après l’ajout de la redéfinition de la méthode equals(Object) à la classe
Personne, on obtient les résultats suivants:

Résultat:
Lotfi Karim est agé de 22 ans.
Lotfi Karim est agé de 22 ans.
p2 est une instance de Personne: true
p1.equals(p2): true 2017-2018
 Remarques
 L’héritage permet:
 la généricité du code: un traitement peut être écrit pour manipuler un
objet d’une classe A, et ce même traitement pourra fonctionner sur
tous les objets dont les classes héritent directement ou indirectement
de la classe A. Exemple: getAge() fonctionne avec des objets des
classes Personne et Etudiant.
 Le polymorphisme: un objet peut se faire passer comme appartenant à
plusieurs classes (toutes celles de sa branche généalogique), et donc
d’être de plusieurs types simultanément.
Exemple: Etudiant E1=new Etudiant();
E1 appartient à la fois aux classes Etudiant et Personne.
 Mais l’utilisation du seul mécanisme de l’héritage produit un code lourd et
parfois peu cohérent quand on essaie d’exploiter ces 2 propriétés.
 3 mécanismes viennent donc compléter et enrichir l’héritage: Les classes
2017-2018
abstraites, les interfaces et les types génériques (Chapitre suivant).
 Suite [2]
 Il ne faut pas confondre la redéfinition avec la surcharge :
 Redéfinition: même type de retour et mêmes paramètres (exp:
toString()).
 Surcharge: type de retour et/ou paramètres différents, les paramètres au
moins doivent être différents (Constructeurs).
 Il n’y’a pas d’héritage multiple en Java, càd, une classe ne peut pas dérivée de
plusieurs classes.
 Une classe définie avec le modificateur d’accès final ne peut pas être dérivée.
 Une méthode définie avec le modificateur d’accès final ne peut pas être
redéfinie dans les classes dérivées. Ceci peut se faire pour des raisons :
 d’efficacité : le compilateur peut générer du code inline, sans faire appel à
la méthode.
 de sécurité : le mécanisme de polymorphisme dynamique fait qu’on ne
sait pas quelle méthode va être appelée.
2017-2018
Section 2: Les classes abstraites

2017-2018
Présentation [1]
 Dans une classe, il est possible de déclarer une méthode comme
étant abstraite, càd que la méthode n’a pas d’implémentation
(code) dans cette classe.

 Mais toutes les classes qui dérivent de celle-ci doivent fournir

une implémentation.

 Quand une classe contient une méthode abstraite, la totalité de la

classe doit être déclarée comme abstraite. Cela signifie qu’une
classe qui inclut au moins une méthode abstraite (càd une classe
abstraite) ne peut pas être instanciée.

2017-2018
 Exemple
 Supposons que nous voulons manipuler deux formes géométriques:
 Rectangle (définie par son point haut, gauche, sa largeur et sa
longueur) et
 Cercle (définie par les coordonnées de son centre et son rayon).
 Nous désirons calculer leur surfaces. Forme
int x, y
Forme()
Surface()

Rectangle Cercle
int larg, long int rayon
Rectangle() Cercle()
Surface() Surface()
2017-2018
La classe abstraite Forme
abstract class Forme{
int x, y;
Forme(int x, int y){
this.x = x;
this.y = y;
}
abstract double surface();
}

2017-2018
La sous classe Rectangle
class Rectangle extends Forme{
int largeur, longueur;
Rectangle(int x, int y, int largeur , int longueur ){
super(x, y);
this.largeur = largeur ;
this.longueur = longueur ;
}
double surface(){
return largeur*longueur;
}
}
2017-2018
La sous classe Cercle
class Cercle extends Forme{
int rayon;
Cercle(int x, int y, int r){
super(x, y);
this.rayon = rayon;
}
double surface(){
return Math.PI*rayon*rayon;
}
}

2017-2018
Avantages
 Les classes abstraites permettent de factoriser du code dans une
classe mère dans laquelle :
 certaines méthodes seront génériques : partagées par toutes
les classes filles.
 certaines méthodes seront spécifiques : propres à chacune des
classes filles et donc définies (de façon obligatoire) dans
chacune d’elles.

2017-2018
 Références
[1] : http://www.i3s.unice.fr/~riveill/cours/langage/99-java-intro.pdf
[2] : http://imss-www.upmf-
grenoble.fr/prevert/Prog/Java/CoursJava/classes2.html
[3] : http://www.jmdoudoux.fr/java/dej/chap-
techniques_java.htm#techniques_java-2
[4]: http://imss-www.upmf-
grenoble.fr/prevert/Prog/Java/CoursJava/interface.html
[5]: http://refg.tu-sofia.bg/JavaCours/intefaces.html#Interfaces

2017-2018