Vous êtes sur la page 1sur 17

Le problème avec l’héritage multiple des

classes

— Voici un cas où l’héritage multiple classique


W a un problème: l’héritage en losange
— Quand W a de l’état (des attributs), qui va
initializer W? X ou Y ou les deux?
— Il n’y a pas de solution simple
X Y — C’est une des raisons pourquoi l’héritage
multiple est interdit en Java
— Nous allons voir comment les interfaces
peuvent résoudre ce problème
Z

133
Héritage multiple

— Java n'autorise pas l'héritage multiple. Une des


raisons de cette restriction est la complexité de
l'implémentation pour le compilateur.
— La notion d'interface a donc été introduite en
Java et elle permet de récupérer la plupart des
fonctionnalités de l'héritage multiple.
— Cette décision dans la conception de Java est en
fait une simplification apportée au langage Java.

134
Interface
— Interface
— Un ensemble de méthodes (comportements) exigées
— Permet de savoir qu’une classe contient les implantations de certaines méthodes
— On peut utiliser ces méthodes sans connaître les détails de leur implantation
— Souvent utilisée pour des types abstraits de données (e.g. pile, queue, …)
— Une classe peut se déclarer conforme à (implanter) une interface: dans ce cas, elle doit
implanter toutes les méthodes exigées
— E.g.
public abstract interface Inter {
public abstract int carre(int a);
public abstract void imprimer();
}
class X implements Inter {
public int carre(int a) { return a*a; }
public void imprimer() {System.out.println("des informations"); }
}

135
Une solution avec les interfaces

— Les interfaces sont marquées en rouge et avec un


W* astérisque (*)
— Il n’y a plus d’héritage en losange: la classe Z hérite
uniquement de la classeY
— Pour les interfaces, l’héritage est uniquement une
X* Y contrainte sur les entêtes des méthodes fournies par les
classes
— La syntaxe Java pour l’exemple du losange:
interface W { }
Z interface X extends W { }
class Y implements W { }
class Z extends Y implements X { }

136
Interface
— Une interface permet de regrouper les objets qui
peuvent manifester le même type de
comportement (mêmes méthodes)
— Interface n’a pas la même contrainte d’héritage
simple pour les classe
— Une classe peut se conformer à plusieurs
interfaces

137
Interface
— Pour implémenter une interface, on utilise: implements
— La classe doit expliciter le code de chaque méthode définie
dans l’interface

class MaClasse implements nomInterface


{

type_retour methode1(paramètres)
{code spécifique à la méthode1 pour cette classe};

… }

138
Exemple d’Interface

interface Electrique class Radio implements Electrique


{ {
void allumer(); // ...
void eteindre(); void allumer()
} {System.out.println(« bruit »);}
void eteindre()
{System.out.println(« silence »);}

class Ampoule implements Electrique


{
// ...
void allumer() {System.out.println(« j’éclaire »);}
void eteindre() {System.out.println(« plus de lumière»);}
}

139
Exemple d’Interface
// …

Ampoule monAmpoule = new Ampoule();


Radio maRadio = new Radio();
Electrique c;
Boolean sombre;

// …

if(sombre == true)
c = monAmpoule;
else
c = maRadio;

c.allumer();

c.eteindre();

// …
140
Utilisation des interfaces
■Une variable peut être définie selon le type d’une interface
■Une classe peut implémenter plusieurs interfaces différentes
■L’opérateur instanceof peut être utilisé sur les interfaces

Exemple :
interface Electrique

interface Lumineux

class Ampoule implements Electrique, Lumineux

Electrique e;
Object o = new Ampoule();
if (o instanceof Electrique) {e=(Electrique)o;e.allumer();}

141
Classe abstraite vs. Interface
— Classe abstraite
— Certaines méthodes peuvent être abstraites
— Peut contenir des attributs
— Peut implanter des méthodes
— Héritage simple
— Interface = contrat
— Aucune implantation de méthode
— Différentes classes peuvent signer le même contrat

— Classe = famille
— posséder le même nom de famille
— a la même habileté (peut être une méthode abstraite)
— Interface = contrat
— Contrat commun pour différentes familles
142
Polymorphisme- Rappel
— Le polymorphisme est la capacité de faire correspondre à un
même message plusieurs méthodes selon le type de l'objet
receveur. Il permet de spécialiser une classe héritée en lui
ajoutant les modifications de traitement spécifiques à la classe.
— Le polymorphisme permet :
- de programmer plusieurs méthodes avec un même nom
- de sélectionner la méthode lors de l'exécution.
— L'appel à une méthode fonctionne au moyen d'une liaison
dynamique : la recherche de la méthode à utiliser est réalisée
lors de l'exécution. C'est dans la classe de cet objet que l'on
définira le comportement de l'objet.
143
Polymorphisme en java
— Le polymorphisme est permis mais est soumis à quelques
contraintes.
— On peut appliquer ce concept qu'entre des classes d'une même
branche d'héritage ou partageant une même interface.
— Le fait que le code Java soit exécuté par une machine virtuelle
qui intègre la technologie objet fait que la gestion du
polymorphisme est assurée par la machine virtuelle qui
décharge le programmeur de la complexité de l'opération.

144
Polymorphisme en java
// Animal avec nom obtenir nom, afficher
abstract class Animal{
private String nom;
Animal(String chaine){
nom= chaine;
}
String getNom(){ return nom; }
abstract void parle();

void afficher(){
System.out.println(nom);
}
} 145
Polymorphisme en java
class Chien extends Animal{
Chien(String chaine){
super(chaine);
System.out.println("\nCreer le chien " + chaine);
}
void afficher(){
System.out.print("\nJe suis le chien ");
super.afficher();
}
void parle(){
System.out.println(" Ouarf! Ouarf!");
}
} 146
Polymorphisme en java
class Chat extends Animal{
Chat(String chaine){
super(chaine); //
constructeur de Animal
System.out.println("\nCreer le chat " + chaine);
}
void afficher(){
System.out.print("\nJe suis le chat ");
super.afficher( );
}
void parle(){
System.out.println(" Miaou! Miaou!");
} 147
}
// Polymorphisme: illustre le polymorphisme etVector
import java.util.*;
public class TestPolymorphisme
{
public static void main (String[] args)
{
Vector animaux = new Vector();
Animal unAnimal;

Chien unChien = new Chien("Snoopy");


animaux.add(unChien);
Chat unChat = new Chat("Felix");
animaux.add(unChat);
animaux.add(new Chat("Garfield"));
animaux.add(new Chien("Pluto"));

for (int i= 0; i < animaux.size(); i++){


unAnimal = (Animal) animaux.get(i);
unAnimal.afficher();
unAnimal.parle();
}
}
}
148
— Exécution du programme:
Creer le chien Snoopy
Creer le chat Felix
Creer le chat Garfield
Creer le chien Pluto
Je suis le chien Snoopy
Ouarf! Ouarf!
Je suis le chat Felix
Miaou! Miaou!
Je suis le chat Garfield
Miaou! Miaou!
Je suis le chien Pluto
Ouarf! Ouarf!

149

Vous aimerez peut-être aussi