Pr. Y.

IDRISSI KHAMLICHI
youness.khamlichi@usmba.ac.ma
Année Universitaire : 2021/2022
https://www.ensaf.ac.ma/formationcontinue/mql2si/
ENSA-Fès

Java Orienté Objet

Partie 2

1 ENSA Fès
Empêcher l’héritage
 Il est possible d’empêcher :
 qu'une classe soit surchargée par une autre classe,
 qu'une méthode soit surchargée par une méthode d'une sous-
classe.
 Il suffit pour cela d'utiliser le mot-clé final, pris en
compte à la compilation.

 De la même façon qu'il est possible d'empêcher quelqu'un

d'étendre une classe, ou de surcharger une méthode,
 il est possible de forcer l'extension ou la surcharge, en
utilisant le mot-clé abstract.

2 ENSA Fès
 Les classes abstraites

3 ENSA Fès
Notion d’abstraction
 Une méthode abstraite
 est simplement déclarée (signature)
 mais ne possède pas de corps défini (bloc d’instructions)
➔ conséquence : reporter sur les classes dérivées (concrètes) la
nécessité de définir le corps de toute méthode abstraite de la
classe de base
 Une classe abstraite
 Une classe contenant au moins une méthode abstraite est
appelée une classe abstraite et cela doit être explicitement
précisé dans la déclaration avec : abstract class

4 ENSA Fès
Classe abstraite : Intérêts
 Il y a plusieurs intérêt à définir des classes abstraites :
 Pour interdire l’instanciation directe d’une classe;
 Il est nécessaire de créer une classe concrète qui l’étende.

 Pour faire de la factorisation de code en ne donnant qu’une

implémentation partielle.
 Exemple :
public abstract class A {
public abstract void f() ; // pas de corps de méthode }

public class B extends A {

public void f() { System.out.println(" le corp de la
méthode f() étendu de la méthode abstract de A, on
parle de l’implémentation");} }
5 ENSA Fès
Les règles : Classe abstraite
 Les règles suivantes s’appliquent aux classes abstraites :
 Une classe abstraite ne peut pas être instanciée : on ne peut
pas créer d'objet en utilisant l'opérateur new.

 Si une sous-classe d'une classe abstraite n'implémente pas

toutes les méthodes abstraites dont elle hérite, cette sous-
classe est elle-même abstraite (et ne peut donc pas être
instanciée).
 Les méthodes déclarées avec l'un des modificateurs suivants :
static, private ou final ne peuvent pas être abstraites étant
donné qu'elles ne peuvent pas être redéfinies dans une sous-
classe

6 ENSA Fès
Exemple (1/6)
 Considérons la hiérarchie de classes suivantes :

surface() Figure

Cercle Rectangle Carre

 on veut que toutes les classes disposent de la méthode

surface() retournant la surface de la figure géométrique
définie par la classe.

7 ENSA Fès
Exemple (2/6)
public abstract class Figure {
private String nom;

//Une classe abstraite ne peut pas être instanciée

//mais elle peut avoir un constructeur :
public Figure(String nom) {
this.nom = nom;
}

//Voilà la méthode abstraite à compléter :

public abstract double surface();

//Toutes les méthodes ne sont pas abstraites :

public void quiSuisJe() {
System.out.println("Je suis un " + this.nom);
}
}

8
Exemple (3/6)

public class Cercle extends Figure{

private double rayon;

public Cercle(double rayon) {

super("cercle");
this.rayon = rayon;
}

public double surface(){

return Math.PI * this.rayon * this.rayon;
}
}

9
Exemple (4/6)
public class Rectangle extends Figure{
private double largeur;
private double longueur;

public Rectangle(double largeur, double longueur) {

super("rectangle");
this.largeur = largeur;
this.longueur = longueur;
}

public double surface(){

return this.largeur * this.longueur;
}
}

10
Exemple (5/6)

public class Carre extends Figure{

private double longueur;
public Carre(double longueur) {
super("Carre");
this.longueur = longueur;
}

public double surface(){

return this.longueur * this.longueur;
}
}

11
Classes abstraites et polymorphisme
Exemple (6/6)
Même si la classe Figure est abstraite, il est tout de même possible
de déclarer des variables de ce type qui pourront recevoir des
objets créés à partir des sous-classes concrètes :
Figure[] dessin = new Figure[3];
dessin[0] = new Rectangle(2.5, 6.8);
dessin[1] = new Cercle(4.66); Constructeur à définir
dessin[2] = new Carre(0.125); dans les classe !

Le polymorphisme permet ensuite d'invoquer une méthode

commune sur chacun des objets :
double surfaceTotale = 0.0;
for (int i=0; i<dessin.length; i++) { // Calcule la somme
surfaceTotale += dessin[i].surface(); // des surfaces
dessin[i].quiSuisJe();
}
System.out.println("la surface totale est : " +surfaceTotale);

12
 Héritage multiple : Interfaces

13 ENSA Fès
Interface
 Définition
 Une interface Java est une sorte de classe abstraite à 100 %
 Sans attributs
 Avec seulement des méthodes abstraites (et publiques)
 Elle peut être vue comme un contrat ou un modèle que doivent offrir
toutes les classes qui se réclame (implémente) de cette interface

 Utilisation
 Une classe concrète qui « dérive » d’une interface
 Doit utiliser le mot-clé implements
 public class B implements A{ … }
 Doit définir toutes les méthodes imposées par l’interface
 elle garantit le protocole défini par l’interfac public class B implements A {
@Override
public void droite() {
public interface A {
...
public void droite();
}
public void gauche();
@Override
}
public void gauche() {
...
}
14 ENSA Fès }
Interface

15 ENSA Fès
Interface
public interface Perimetre { public float per(); } Rectangle implémente
les interfaces Perimetre,
public interface Surface { public float sur(); } Surface et Resultat
public interface Resultat { public void result(); }

public class Rectangle implements Perimetre, Surface, Resultat {

private float A, B;
public Rectangle(float a, float b) { A = a; B = b; }
public float per() { return (2*(A+B)); }
public float sur() { return (A*B); }
public void result() {
System.out.println("Perimetre = " + per());
System.out.println("Surface = " + sur()); }
}

public class Test1interface {

public static void main(String [] args){
Rectangle R = new Rectangle(2.5f, 4.0f);
R.result(); }
}
16 ENSA Fès
Interface
❑ Le corps d'une interface ressemble beaucoup à celui d'une classe
abstraite avec cependant les différences suivantes :
✓ Une interface ne peut définir que des méthodes abstraites. Le
modificateur abstract n'est pas nécessaire.
✓ Toutes les méthodes abstraites sont implicitement publiques
même si le modificateur public est omis.
✓ Une interface ne peut pas contenir de méthodes statiques.
✓ Une interface ne peut pas définir de champs d'instance.
✓ Une interface peut cependant contenir des constantes déclarées
static et final (tous les champs sont implicitement static et final
même si les modificateurs correspondants sont omis).
✓ Une interface ne définit pas de constructeur (on ne peut pas
l'instancier et elle n'intervient pas dans le chaînage des
constructeurs).

17 ENSA Fès
Interface
 les méthodes déclarées dans l’interface doivent être
définies dans les classes qui l’implémentent avec le même
nom, le même type pour les paramètres et le résultat.

 De plus ces méthodes doivent être définies avec le mot-

clé public.

 L'implémentation d'une ou de plusieurs interfaces

(implements) peut être combinée avec l'héritage simple
(extends).

 La clause implements doit suivre la clause extends.

18
 Interface
public interface Perimetre { public float per(); }

public interface Surface { public float sur(); }

public interface Resultat { public void result(); }

public class Rectangle implements Perimetre, Surface{
protected float A, B;
public Rectangle(float a, float b) { A = a; B = b; }
public float per() { return (2*(A+B)); }
public float sur() { return (A*B); } }

public class Square extends Rectangle implements Resultat{

public Square(float a) { super(a, a); }
public void result() {
System.out.println("Perimetre = " + per());
System.out.println("Surface = " + sur()); }
} Square hérite de
public class Test1interface { Rectangle
public static void main(String [] args){
Square S = new Square(5.0f);
S.result(); }
}
19
Utilisation des interfaces
 Lorsqu'une classe déclare une interface dans sa clause
implements, elle indique ainsi qu'elle s'engage à fournir une
implémentation (c'est-à-dire un corps) pour chacune des
méthodes de cette interface.
 Si une classe implémente une interface mais ne fournit pas
d'implémentation pour toutes les méthodes de l'interface, elle
hérite des méthodes (abstraites) non implémentées de
l'interface et doit elle-même être déclarée abstract.
 Si une classe implémente plus d'une interface, elle doit
implémenter toutes les méthodes de chacune des interfaces
mentionnées dans la clause implements (ou alors être déclarée
abstract).

20
Interface
 Les points à prendre en considération sont les suivants :
 Une interface est une pure spécification, si elle contient un
grand nombre de méthodes, il peut être fastidieux de toutes
les implémenter (il n'est pas possible de définir des
comportements par défaut).
 La compatibilité ascendante en cas de modification doit être
considérée. Si l'on ajoute de nouvelles méthodes à une
interface, toutes les classes qui l'implémentent doivent
implémenter les nouvelles méthodes.

21
Interface
 Un modèle de conception impliquant les deux approches
constitue la meilleure solution :
 Création d'une interface (totalement abstraite)
 Création d'une classe abstraite qui implémente l'interface
créée et qui fournit des méthodes par défaut dont les sous-
classes pourront profiter
 Avec cette approche, les utilisateurs pourront choisir
entre implémenter l'interface en créant le corps de
toutes les méthodes abstraites ou alors en sous-classant
la classe abstraite et en n'implémentant ou ne
redéfinissant que les méthodes nécessaires (les autres
méthodes étant héritées avec le comportement par
défaut).

22
Exemple
public interface Imprimable {
public void print();
}
public abstract class Figure implements Imprimable {
public abstract double perimetre(); // Méthode abstraite
public abstract double surface(); // Méthode abstraite
}
public class Cercle extends Figure {
public static final double PI = 3.14159265358979;
protected double rayon;
public Cercle(double rayon) {
this.rayon = rayon;
}
public double getRayon() { return rayon; }
public double perimetre() { return 2*PI*rayon; }
public double surface() { return PI*rayon*rayon; }
public void print() { ... }
}
23
Interface
 Les interfaces peuvent avoir des sous-interfaces (tout comme les
classes peuvent avoir des sous-classes). Comme pour les classes, le
mot-clé extends est utilisé pour créer une sous-interface.

public interface Cercle extends Figure{...}

 Une sous-interface hérite de toutes les méthodes abstraites et de

toutes les constantes de son interface parente et peut définir de
nouvelles méthodes abstraites ainsi que de nouvelles constantes.

 Une classe qui implémente une sous-interface doit implémenter les

méthodes abstraites définies directement par l'interface ainsi que les
méthodes abstraites héritées de toutes les interfaces parentes de la
sous-interface.

24