<!-- Slide number: 1 -->
Classes abstraites & interfaces en Java
<!-- Slide number: 2 -->
Plan
Classes abstraites
Interfaces
<!-- Slide number: 3 -->
Concept des classes abstraites
Le mécanisme de classe abstraite permet de définir des comportements (méthodes) qui seront implémentés dans les classes filles.
Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle sert de classe de base pour les dérivations.
Exemple:
Soit la classe Humain, à partir de laquelle dérivent les classes Homme et Femme.
Il est possible de créer des objets des classes Homme et Femme, par contre il n’est pas possible d’avoir un objet de la classe Humain!
<!-- Slide number: 4 -->
Méthode abstraite
Dans une classe abstraite, on peut trouver des attributs et des méthodes dont héritera toute classe dérivée.
Dans une classe abstraite, on peut trouver des méthodes abstraites: qui fournissent uniquement la signature et le type de retour (prototype).
<!-- Slide number: 5 -->
Syntaxe:
abstract class A {
Public void m1() { ….} // m1 est définie dans A
Public abstract void m2 (int n); / m2 méthode abstraite, elle n’est pas définie dans A /
Public class B extends A { …}
…}
A a; // on peut déclarer une référence sur un objet de type A ou dérivé
a = new A (…); //Erreur! Pas d’instanciation d’objet d’une classe abstraite
b = new B (…); // On peut instancier un objet b de la classe B qui dérive de A
<!-- Slide number: 6 -->
Si une classe comporte une méthode abstraite alors elle est abstraite, même si on n’indique pas le mot clé abstract devant sa déclaration.
Une méthode abstraite doit obligatoirement être déclarée public, ce qui est logique puisque sa vocation est d’être redéfinie dans une classe dérivée.
Ce qui est logique puisque sa vocation est d’être redéfinie dans une classe dérivée.
Les noms des paramètres formels (ou muets) doivent être déclarés
Exemple:
public abstract void m(int); //erreur: nom paramètre formel est obligatoire
public abstract void m(int x);
<!-- Slide number: 7 -->
Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir toutes les méthodes abstraites.
Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.
<!-- Slide number: 8 -->
Intérêt des classes abstraites
Les classes abstraites facilitent la conception orientée objet: on peut placer dans une classe abstraite toutes les fonctionnalités dont on souhaite disposer dans les classes descendantes:
Sous forme d’une implémentation complète de méthodes (non abstraites) et de champs (privés ou pas), lorsqu’ils sont communs à tous les descendants.
Publicité
Sous forme d’interface de méthode abstraite qui existeront obligatoirement dans toutes les classes dérivées
<!-- Slide number: 9 -->
Exemple:
abstract class Graphique{
private int x,y;
Graphique (int x, int y) {This.x = x; This.y = y; }
Void affiche () {
System.out.println(« Le centre de l’objet se trouve dans:" + x + "et" + y);
}
Abstract public double surface (); // méthode abstraite
}
<!-- Slide number: 10 -->
class Cercle extends Graphique {
private double rayon =1;
Cercle (intx, int y, int r){
super(x,y);
rayon = r;
}
void affiche() {
System.out.println("c’est un cercle de rayon" + rayon);
Super.affiche();
//remplace System.out.println(« Le centre de l’objet se trouve dans:" + x + "et" + y);
}
double surface(){
return (rayon 2 3,14);
}
}
<!-- Slide number: 11 -->
Class Rectangle extends Graphique {
private int larg, longueur;
Rectangle ( int x, int y, int l1, int l2) {
super (x,y); // appel au constructeur de la classe mère
Longueur = l1;
Larg = l2;
}
double surface() {
return (longueur * larg);
}
<!-- Slide number: 12 -->
Class test-poly2 {
Public static void main(String [] args) {
Graphique [] tab = new Graphique [6]; // déclaration du tableau tab
Publicité
tab[0] = new graphique (3,2); //erreur! Car une classe abstraite ne peut pas être instanciée
tab[0] = new Cercle (3,2,7);
tab[1] = new Reclangle (4,7,8,6);
….
for (int i = 0; 1 <= 5 ; i++)
{ tab[i].affiche();}
}}
<!-- Slide number: 13 -->
Concept d’Interface
Une classe abstraite peut ne comporter que des méthodes abstraites et aucun attribut. Dans ce cas, on peut utiliser le concept d’interface.
Une interface définit les entêtes de méthodes et des constantes.
<!-- Slide number: 14 -->
Classe abstraite vs interface
L’interface est plus riche qu’une simple classe abstraite, puisque:
Une classe peut implémenter plusieurs interfaces alors qu’une classe ne peut dériver que d’une seule classe abstraite.
La notion d’interface va compléter, et non pas remplacer, celle de dérivée: les interfaces peuvent se dériver.
Une classe dérivée peut implémenter 1 ou plusieurs interfaces, elle peut même réimplémenter une interface déjà implémentée par la superclasse
On pourra utiliser des variables de type interface.
<!-- Slide number: 15 -->
Définition d’une interface
Dans une interface, toutes les méthodes sont abstraites.
Remarque:
On peut ne pas mentionner le modificateur de visibilité (par défaut public) et le mot clé abstract.
Exemple:
public interface I1 {
void m1(int n); // public abstract facultatifs
void m2 (); // public abstract facultatifs
}
<!-- Slide number: 16 -->
Implémentation d’une interface
Syntaxe:
public interface I1 {
….}
public interface I2 {
….}
class A implements I1, I2 {
….. A doit définir les méthodes de I1 et I2}
<!-- Slide number: 17 -->
Exemple:
Interface Affichable{ // Création d’une interface appelée Affichable
void affiche();
}
Publicité
Class Entier implements Affichable{
private int val;
Public Entier (int n) {
val = n;
}
public affiche () { System.out.println("je suis un entier de valeur "+val); }
class Flottant implements Affichable {
private float val;
Public Flottant (float n) {
val = n;
}
public affiche () { System.out.println("je suis un flottant de valeur "+val); }
<!-- Slide number: 18 -->
Public class TestInterface {
public static void main(String [] args) {
Affichable [] tab = new Affichable [2]; // déclaration d’un tableau de taille 2
tab[0] = new Entier (25);
tab[1] = new flottant (1.25);
tab[0].affiche();
tab[1].affiche();
}
}
Résultat:
je suis un entier de valeur 25
je suis un flottant de valeur 1.25
<!-- Slide number: 19 -->
Interfaces et constantes:
Une interface peut renfermer aussi des constantes qui seront accessibles à toutes les classes implémentant l’interface.
Les constantes déclarées sont toujours considérées comme static et final.
Exemple:
Public interface I {
void m (int n);
void m2 ();
static final int max = 100;
}
<!-- Slide number: 20 -->
Interface et dérivation:
L’interface est totalement indépendante de l’héritage: une classe dérivée peut implémenter une ou plusieurs interfaces.
Exemple:
Interface I1 {……}
Interface I2 {……}
Class A impléments I1 {……}
Publicité
Class B extends A implements I1, I2 { …..}
<!-- Slide number: 21 -->
On peut définir une interface comme une généralisation d’une autre: on utilise alors le mot clé extends.
Exemple:
Interface I1 {
void m1(int n);
static final int max =100;
}
Interface I2 extends I1 {
void m2(int n);
static final int min = 10;
}
La définition de I2 équivaut à:
interface I2 { void m2(int n);
static final int min = 10;
void m1(int n);
static final int max =100;
}
<!-- Slide number: 22 -->
Conflits de noms (ou collision):
Des conflits de noms ou collisions peuvent se produire lorsqu’une classe implémente plusieurs interfaces comportant des noms de méthodes ou de constantes identiques.
Il suffit de distinguer plusieurs situations:
Plusieurs méthodes portent des signatures identiques:
Exemple:
Interface I1 {
void m1(int n);
void m2();
}
Interface I2 {
void m1(float n);
void m2();
}
Class A implements I1, I2 {
// A doit implémenter la méthode m2 qui existe dans les 2 interfaces une seule fois
<!-- Slide number: 23 -->
Si 2 méthodes portent le même nom avec des profils de paramètres différents:
Implémentation de 2 ou plusieurs méthodes surchargées.
Si 2 méthodes portent le même nom avec des profils de paramètres identiques mais type de valeur de retour différents:
Pas possible d’implémenter les 2 interfaces : cela provoque une erreur à la compilation: Interface-collision.