Chap5 Classe Abstraite Et Interface

Classe abstraite et interface
 Classe abstraite
 C’est une classe qui ne peut pas être directement instanciée.
Elle sert comme une classe de base pour une dérivation
(héritage)
 Une classe abstraite est déclarée avec le modificateur
abstract
 Syntaxe :
abstract class nom_classe { … }
 Une classe abstraite est une classe qui peut contenir une ou
plusieurs méthodes abstraites. Elle peut aussi contenir
des méthodes normales (méthodes concrètes)
2 Mohamed Aymen CHARRADA 27/11/2023

 Méthode abstraite
 C’est une méthode qui ne contient pas de corps. Elle
possède tout simplement une signature (entête) suivie du
caractère point-virgule
 Une méthode abstraite doit obligatoirement être déclarée
avec le modificateur abstract
 Syntaxe :
abstract type_retour nom_fct (liste args);
 Exemple :
public abstract double fct ( );
 Une classe possédant une ou plusieurs méthodes abstraites
devient obligatoirement une classe abstraite
 Une méthode abstraite ne peut pas être déclarée static ou
3
private
Mohamed ou final
Aymen CHARRADA 27/11/2023
 Classe abstraite A a ;
//on peut déclarer une référence
 Exemple //sur un objet de type A ou dérivé
abstract class A { a = new A (….) ;
public void f() {……} //Erreur impossible d’instancier
//f est définie dans A //une classe abstraite
public abstract void g (int n) ; a = new B(…) ;
//g est une méthode abstraite //Correcte car B n’est pas une
//classe abstraite et elle hérite
//elle n’est pas définie dans A
//de la classe A
}
Class B extends A {
//B définit toutes les
//méthodes abstraites de A
public void g (int n) { … }
}

 Dès qu’une classe abstraite comporte une ou plusieurs
méthodes abstraites, elle est abstraite
 Une classe fille d'une classe abstraite ne peut être instanciée
que si elle définit (fournit une implémentation) pour
chaque méthode abstraite de sa classe mère. Dans ce cas,
elle sera une classe normale (concrète)
 Si une classe fille d'une classe abstraite n'implémente pas
toutes les méthodes abstraites qu’elle a hérité, cette classe
fille est elle-même abstraite

 Classe abstraite // Classe C qui hérite A
Class C extends A {
 Exemple public void F (int a) { … }
// Classe abstraite public int G (String s) { … }
abstract Class A { }
int a; « C » est une classe non
public abstract void F (int a); abstraite puisqu’elle a
public abstract int G (String s); implémenté toutes les
private void H ( ) { ….} méthodes abstraites de A
}
// Classe B qui hérite A
Class B extends A {
int x; « B » est une classe
public void F (int a) { … } abstraite car elle n’a pas
public void I (String s) { … } définit toutes les méthodes
} abstraites héritées

 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 classe fille
 Une classe déclarée final ne peut pas contenir de méthodes
abstraites car elle ne peut pas être héritée
 Une classe peut être déclarée abstract même si elle ne
possède pas réellement de méthode abstraite (mais ce n’est
pas utile)

 Classe abstraite final Class C {
public int G (String s) { … }
 Exemple public abstract void F (int a);
abstract Class A { }
int a; // Faux car une classe finale ne
public void F (int a) { … } //peut pas contenir une méthode
private void H ( ) { … } //abstraite
}
// Correcte même si A ne contient
//pas des méthodes abstraites
abstract Class B {
int x;
private abstract void F (int a);
}
// Faux car une méthode privée
//ne peut pas être abstraite et
//ne peut pas être redéfinie
 Si l'on souhaite, par exemple, créer une hiérarchie de
classes qui décrivent des formes géométriques à deux
dimensions, on pourrait envisager l'arborescence
représentée par le diagramme de classes suivant :
Forme
Cercle Rectangle Triangle
Carré
 Sachant que toutes les formes possèdent les propriétés
périmètre et surface, il est judicieux de placer les
méthodes définissant ces propriétés dans la classe qui est à
la racine de l'arborescence (Forme)
 La classe « Forme » ne peut cependant pas implémenter
ces deux méthodes car on ne peut pas calculer le périmètre
et la surface sans connaître le détail de la forme
 On doit garantir l’implémentation de ces méthodes dans
chacune des sous-classes de la classe « Forme »
 Il est possible de résoudre ce problème en déclarant dans la
classe « Forme » deux méthodes abstraites perimetre()
et surface() ce qui rend la classe « Forme » elle-même
10
abstraite et impose aux sous-classes de les implémenter
Mohamed Aymen CHARRADA 27/11/2023
} //Fin de Cercle
Public class Rectangle extends Forme
public abstract class Forme { { public double long, larg;
public abstract double perimetre(); public Rectangle (double long, double
public abstract double surface(); larg) {
}//Fin de Forme this.long = long;
public class Cercle extends Forme { this.larg = larg;
public static final double PI = 3.14; }
private double rayon; public double perimetre() {
public Cercle (double rayon) { return (2*(long+larg));
this.rayon = rayon; }
} public double surface() {
public double perimetre() { return (long*larg);
return (2*PI*rayon); }
} }//Fin de Rectangle
public double surface() {
return (PI*rayon*rayon);
}
 Les autres sous-classes (Carre, Triangle, ...) pourraient être
implémentées selon le même modèle
 Même si la classe « Forme » est abstraite, il est tout de
même possible de déclarer un tableau de références de ce
type qui pourront recevoir des objets créés à partir des
sous-classes concrètes :
Forme [] DS = new Forme [3];
DS [0] = new Rectangle (2.5, 6.8);
DS [1] = new Cercle (4.66);
DS [2] = new Carre (2.7);

 Le polymorphisme permet ensuite d'invoquer une méthode
commune sur chacun des objets :
double totalSurface= 0;
// Calcule la somme des surfaces
for (inti=0; i<DS.length; i++) {
totalSurface+= DS[i].surface();
}

 Interface
 C’est une sorte de « classe » purement abstraite qui
contient uniquement des méthodes abstraites et publiques
et des constantes
 Du point de vue syntaxique, la définition d'une interface est
proche de celle d'une classe abstraite
 Il suffit de remplacer les mots-clés « abstract class » par
le mot-clé « interface »
 Syntaxe :
Modificateur interface nom_interface {
//liste des méthodes publiques abstraites et constantes
}

 Interface
 Le corps d'une interface peut contenir :
 Des constantes qui sont implicitement publiques : L’utilisation des
modificateurs « static » et « final » ne sont pas nécessaires
(implicites)
 Des méthodes abstraites publiques :
 Le modificateur abstract n'est pas nécessaire (implicite).
 Le modificateur public n'est pas nécessaire (implicite).
 Des méthodes avec une implémentation par défaut : Le
modificateur default doit être utilisé (voir la suite) (Java 8)
 Des méthodes statiques (Java 8)
 Par contre
 Une interface ne peut pas définir des variables et des instances
 Une interface ne définit pas de constructeur

 Interface
 Exemple :
public interface I {
int a = 3; // a est implicitement une constante
void f () ; // f est implicitement publique et abstraite
public default void g () { … } //g est une fonction avec
//implémentation par défaut
static int h (String s) { … } // h est une méthode statique

String str; // pas de variable
public I () { } // pas de constructeur
public void F ( ) { … } // pas de méthode concrète
}

 Interface
 Le modificateur d’une interface ne peut être que « public »
ou néant (accès package)
 On peut créer des références ayant une interface comme
type
 Par contre, on ne peut pas, dans le cas général, instancier
une interface
 Exemple :
interface Comparable {
public int compareTo (Object o);
}
Une fois l'interface déclarée, il est possible de déclarer des
variables de ce (nouveau) type :
Comparable C;
C = new Comparable ();
Mohamed Aymen CHARRADA Comparable [ ] tab; 27/11/2023
17
 Interface
 En Java, une classe ne peut hériter que d'une et d'une seule
classe mère (héritage simple)
 Une classe peut, par contre, implémenter une ou plusieurs
interfaces en utilisant la syntaxe suivante :
Class nom_classe implements interface1, interface 2, … {
… }
 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 »
 Exemple :
Class A extends B implements C, D { … }

 Interface
 Lorsqu’une classe implémente une interface, elle doit
fournir une implémentation (une définition) pour chacune
des méthodes abstraites (sans corps) de cette interface
 Si une classe implémente une interface mais ne fournit pas
d'implémentation pour toutes les méthodes abstraites de
l'interface, elle hérite alors des méthodes non implémentées
de l'interface et doit être déclarée « abstract »
 Si une classe implémente plus d'une interface, elle doit
implémenter toutes les méthodes abstraites de chacune des
interfaces mentionnées dans la clause « implements » (ou
alors être déclarée abstract)

 Interface
 Exemple
interface I {
public int f (String a) ;
public void g ();
}
Class C1 implements I {
public int f (String a) { … }
public void g () { … }
}
//Correcte car C1 implémente toutes les méthodes de I
}
// Erreur C2 doit être abstraite puisqu’elle n’implémente pas
//toutes les méthodes de I

 Interface
 Exemple
interface I1 { interface I2 {
public int f (String a) ; public void h (int x);
public void g (); }
}
Class C1 implements I1, I2 {
}
// Erreur C1 doit être abstraite puisqu’elle n’implémente pas
//toutes les méthodes de I1 et I2
Class C2 implements I1, I2 {
public void h (int x) { …}
}
//Correcte car C2 implémente toutes les méthodes de I1 et I2
Mohamed Aymen CHARRADA
21 27/11/2023
 Extension des interfaces
 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 I1 extends I2 { ... }
 Une sous-interface hérite toutes les méthodes et toutes les
constantes de son interface mère et peut ajouter de
nouvelles méthodes ainsi que de nouvelles constantes.
 Contrairement aux classes, une interface peut posséder
plusieurs interfaces parentes (héritage multiple).
public interface I1 extends I2, I3, … { ... }

Interface I
Méthodes abstraites M1, M2, M3
implements
Classe C1 Classe C2 Classe C3
Implémentation de M1, Implémentation de M1, Implémentation de M1,
M2, M3 M2, M3 M2, M3
 Problème :
La modification (ou l’ajout) d'une ou plusieurs méthodes de
(à) l’interface « I » oblige à adapter en conséquence toutes
les classes qui implémentent cette interface

Interface I
Méthodes abstraites M1, M2, M3, M4

M2, M3, M41 M2, M3, M42 M2, M3, M43
 Si on ajoute une méthode abstraite « M4 » à l’interface « I

», les classes « C1 », « C2 » et « C3 » doivent implémentées
cette nouvelle méthode (ou bien elles deviennent abstraites)

Interface I
Méthodes abstraites M1, M2, M3,
Méthode par défaut M4

M2, M3, M4 M2, M3, M4 M2, M3, M4
 Solution :
Utiliser les méthodes par défaut (default method) dans
l’interface

 Une méthode par défaut définit son comportement
dans l'interface où elle est définie (admet un corps)
 Si aucune implémentation de la méthode par défaut n'est
fournie dans une classe qui implémente l'interface alors
c'est le comportement, par défaut, défini dans l'interface
qui sera utilisé
 Une méthode par défaut est déclarée en utilisant le mot clé
default.
 Les méthodes par défaut permettent l'ajout (la
modification) d'une méthode à une interface existante sans
avoir à modifier les classes qui l'implémentent

 Extension des interfaces Class C2 implements I {
public int g () { … }
 Exemple default void M() {
public interface I { System.out.println ("Nouvelle
default void M() { Implementation");
System.out.println }
("Implementation par defaut"); // « C2 » a redéfinit la méthode
} //« M », la nouvelle
public void g(); //implémentation cachera
//l’implémentation par défaut de
}
//la méthode dans l’interface
}
// « C1 » n’a pas redéfinit la
//méthode « M » donc elle utilise
//l’implémentation par défaut de
//cette méthode fournie dans
//l’interface « I »
 Une classe qui implémente une interface n'a pas l'obligation
de redéfinir ses méthodes par défaut
 La redéfinition d'une méthode par une classe ou une super-
classe est toujours prioritaire par rapport à la méthode par
défaut
 Il est aussi possible de créer directement une instance d'une
interface si toutes ses méthodes sont des méthodes par
défaut
 Une interface peut hériter d'une autre interface qui contient
une méthode par défaut et peut redéfinir cette méthode, la
méthode redéfinit peut être par défaut ou abstraite

 Exercice 1
 Peut on instancier une interface? Une classe abstraite?
Correction : Non pour une classe abstraite et
généralement non pour une interface sauf si
l’interface ne contient que des méthodes par défaut
 Peut on mettre un constructeur dans une interface ? Une
classe abstraite?
Correction : Non pour les interfaces, oui pour les
classes abstraites
 Peut on écrire le code suivant : A a = new B ();
 Si A est une classe abstraite héritée par la classe B?
 Si A est une interface implémentée par la classe B?
Correction : oui pour les deux à condition que B ne
soit pas une classe abstraite
 Exercice 1 (suite)
 Quelles sont les types de méthodes qui peuvent appartenir à
une interface?
Correction : Avant Java 8, les méthodes publiques
abstraites et non statiques. Après Java 8, les méthodes
statiques et les méthodes par défaut non statiques
 Une interface peut elle hériter d’une autre interface? D’une
classe abstraite?
Correction : oui pour la 1ère et non pour la 2ème
 Une classe abstraite peut elle hériter d’une autre classe
abstraite? D’une interface?
Correction : Oui pour la 1ère et non pour la 2ème
(pour la 2ème, elle peut l’implémenter)
 Exercice 2 class B extends A {
void fct (A m){
 Dites si le code suivant est
System.out.println(“abc");
correcte ou non? Justifiez }
votre réponse }// Fin de la classe B
abstract class A {
int i = 1;
static int j = 3;
void fct();
public A(){
i = 4;
this.j = 5;
}
} // Fin de la classe A

 Exercice 3 abstract class E implements I {
public void m(){
 Dites si le code suivant est
System.out.println ("E");
correcte ou non? Justifiez }// Fin de la classe E
votre réponse }
interface I {
int i;
public void m();
} // Fin de l’interface I
class D implements I {
public int m(){
System.out.println ("D");
}
} // Fin de la classe D

}//Fin Toto
 Exercice 4
class Tete extends Toto{
 Dites si le code suivant est private int i;
correcte ou non? Sinon, public Tete(){
corrigez-le et donnez le super();
résultat this.i = 2;
}
interface Titi { public int m1(){return this.i;}
int m1(); public int m2(){return super.i;}
} // Fin Titi }//Fin Tete
interface Tutu extends Titi { public class Test {
int m1(); public static void main(String[] arg){
int m2(); Tete t = new Toto();
} //Fin Tutu System.out.println(t.m1());
abstract class Toto implements Tutu{ System.out.println(t.m2());
private int i; }
public Toto(int j){ }//Fin Test
super();
this.i = j;
33 } Mohamed Aymen CHARRADA 27/11/2023
 Exercice 5
 Un compte bancaire admet une référence (chaine) et un solde (réel).
Un compte peut être de débit ou de crédit. Le retrait à partir d’un
compte de débit n’est possible que si le solde couvre le montant à
retirer. Un compte de crédit admet de plus un montant crédit (le
rouge). Le retrait à partir d’un compte de crédit n’est possible que si
le solde couvre le montant à retirer ou bien si le compte ne serait pas
débiteur d’une somme qui dépasse, après retrait, le montant crédit.
 Ecrire la classe « Compte » qui admet un constructeur à deux
arguments, les accesseurs et les modificateurs des attributs ainsi que deux
méthodes « deposer » et « retirer ». L’objectif de ces deux méthodes
est d’appliquer la modification nécessaire sur le solde du compte puis
d’afficher si la modification a été effectuée avec succès ou non. A votre
avis, quel est la nature préconisée de chacune des deux méthodes
« deposer » et « retitrer » ainsi que de la classe « Compte »
34 27/11/2023
 Ecrire la classe « CompteDebit » qui hérite de la classe
« Compte » et qui admet un constructeur à deux arguments
 De même, écrire la classe « CompteCredit » qui hérite de la
classe « Compte » et qui admet un constructeur à trois
arguments
 Ecrire la classe principale « Test » où vous devez créer deux
comptes : « cmp1 » de type « CompteDebit » et « cmp2 » de
type « CompteCredit » puis appliquer sur ces deux comptes
des opérations de dépôt et de retrait
35 27/11/2023
 Ecrire la classe « CompteDebit » qui hérite de la classe
« Compte » et qui admet un constructeur à deux arguments
 De même, écrire la classe « CompteCredit » qui hérite de la
classe « Compte » et qui admet un constructeur à trois
arguments
 Ecrire la classe principale « Test » où vous devez créer deux
comptes : « cmp1 » de type « CompteDebit » et « cmp2 » de
type « CompteCredit » puis appliquer sur ces deux comptes
des opérations de dépôt et de retrait
36 27/11/2023
 Solution

 Solution (suite)




Chap5 Classe Abstraite Et Interface

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap5 Classe Abstraite Et Interface

Transféré par

Droits d'auteur :

Formats disponibles

Classe abstraite et interface

2 Mohamed Aymen CHARRADA 27/11/2023

4 Mohamed Aymen CHARRADA 27/11/2023

5 Mohamed Aymen CHARRADA 27/11/2023

6 Mohamed Aymen CHARRADA 27/11/2023

7 Mohamed Aymen CHARRADA 27/11/2023

Cercle Rectangle Triangle

12 Mohamed Aymen CHARRADA 27/11/2023

13 Mohamed Aymen CHARRADA 27/11/2023

14 Mohamed Aymen CHARRADA 27/11/2023

15 Mohamed Aymen CHARRADA 27/11/2023

static int h (String s) { … } // h est une méthode statique

16 Mohamed Aymen CHARRADA 27/11/2023

18 Mohamed Aymen CHARRADA 27/11/2023

19 Mohamed Aymen CHARRADA 27/11/2023

20 Mohamed Aymen CHARRADA 27/11/2023

22 Mohamed Aymen CHARRADA 27/11/2023

23 Mohamed Aymen CHARRADA 27/11/2023

Classe C1 Classe C2 Classe C3

 Si on ajoute une méthode abstraite « M4 » à l’interface « I

24 Mohamed Aymen CHARRADA 27/11/2023

Classe C1 Classe C2 Classe C3

25 Mohamed Aymen CHARRADA 27/11/2023

26 Mohamed Aymen CHARRADA 27/11/2023

28 Mohamed Aymen CHARRADA 27/11/2023

31 Mohamed Aymen CHARRADA 27/11/2023

32 Mohamed Aymen CHARRADA 27/11/2023

37 Mohamed Aymen CHARRADA 27/11/2023

38 Mohamed Aymen CHARRADA 27/11/2023

39 Mohamed Aymen CHARRADA 27/11/2023

40 Mohamed Aymen CHARRADA 27/11/2023

Vous aimerez peut-être aussi