▪ Java ne permet pas l’héritage multiple

▪ Or, il existe parfois différentes classifications possibles selon

plusieurs critères

2
▪ Selon la forme

Solides convexes

Polyèdres Solides de révolution

Parallélépipède
Cylindres Sphères

Cube

3
▪ Selon la matière

matiere

Matiere organique composée minéral

carbone

4
▪ D’autres critères qui pourraient servir à réaliser une
classification décrivent des comportements ou des capacités
▪ « électrique »
▪ « comestible »
▪ « lumineux »

▪ Or ces « mécanismes » peuvent être commun à différentes

classes non reliées entre elles par une relation d ’héritage

5
 Pour définir qu'une certaine catégorie de classes doit
implémenter un ensemble de méthodes, on peut regrouper
les déclarations de ces méthodes dans une interface.
 Le but est de décrire le fait que de telles classes pourront ainsi
être manipulées de manière identique.
 Exemple :
 Tous les appareils électriques peuvent être allumés ou éteint
 Tous les objets comestibles peuvent être mangés
 Tous les objets lumineux éclairent

6
 Une interface est donc la description d’un ensemble des méthodes
que les classes Java peuvent mettre en œuvre.

 Les classes désirant appartenir à la catégorie ainsi définie

 déclareront qu'elles implémentent cette interface,
 fourniront le code spécifique des méthodes déclarées dans cette
interface.

 Cela peut être vu comme un contrat entre la classe et l’interface

 la classe s’engage à implémenter les méthodes définies dans l’interface

7
 Mot réservé : interface
 Dans un fichier nom_interface.java, on définit la liste de
toutes les méthodes de l’interface

interface nomInterface {
type_retour methode1(paramètres);
type_retour methode2(paramètres);
… }

 Les méthodes d'une interface sont abstraites : elles seront

écrites spécifiquement dans chaque classe implémentant
l’interface

 Le modificateur abstract est facultatif.

8
 Mot réservé : 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};

… }

9
 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»);}
}

10
// …

Ampoule monAmpoule = new Ampoule();

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

// …

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

c.allumer();
…
c.eteindre();

// …

11
 Une instance 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();}

12
 Depuis les débuts de Java, il est possible d'utiliser l'héritage
multiple avec les interfaces.
L'héritage d'interfaces est possible depuis la version 1.0 de Java :
une interface ne peut contenir que la déclaration de constantes et de
méthodes mais elle ne contient pas leurs traitements

A partir de Java 8, il est possible de définir des méthodes static et

par défaut dans une interface.

Elles permettent de définir le comportement d'une méthode dans

l'interface dans laquelle elle est définie. Si aucune implémentation
de la méthode n'est fournie dans une classe qui implémente
l'interface alors c'est le comportement défini dans l'interface qui
sera utilisé. 13
 Une méthode par défaut est déclarée en utilisant le mot clé
default. Le corps de la méthode contient l'implémentation des
traitements.

Exemple :
public interface MonInterface {
default void maMethode() {
System.out.println("Implementation par defaut");
}
}

14
 Les méthodes par défaut proposent une implémentation par défaut qui sera
invoquée si la classe implémentant l'interface ne redéfinit pas explicitement la
méthode.
Une classe qui implémente une interface n'a donc pas l'obligation de redéfinir
une méthode par défaut. Si celle-ci n'est pas redéfinie alors c'est l'implémentation
contenue dans l'interface qui est utilisée.

Exemple :
public interface Service {
default void afficherNom() {
System.out.println("Nom du service : inconnu"); } }

public class MonService implements Service { }

public class TestMethodeParDefaut {

public static void main(String[] args) { Résultat :
Service service = new MonService(){}; Nom du service : inconnu
service.afficherNom(); } }
15
 Si la classe redéfinit la méthode alors c'est l'implémentation de la méthode qui
est utilisée.

Exemple :
public interface Service {
default void afficherNom() {
System.out.println("Nom du service : inconnu"); } }

public class MonService implements Service {

@Override
public void afficherNom() {
System.out.println("Nom du service : mon service"); }
}

public class TestMethodeParDefaut {

public static void main(String[] args) {
Service service = new MonService(){}; Résultat :
service.afficherNom(); } }
Nom du service : mon service

16
 Une méthode statique est un élément que l'on peut rencontrer dans une classe
normale. Un appel statique se fait au travers de la classe, il n'a besoin d'aucune
instance pour être exécuté. Java 8 autorise des méthodes statiques dans les
interfaces, qui obéissent aux mêmes règles que celles que l'on trouve dans les
classes abstraites ou concrètes.

17
interface I {
// Méthode statique
static void hello() {
System.out.println(" Je suis une méthode statique"); }
void afficher (String s);
}

public class ClassA implements I {

public void afficher(String s)
{ System.out.println(s); }

public static void main(String[] args){

ClassA A = new ClassA();
ClassA.hello();
A. afficher(“Redéfinition de méthode afficher “);
}
Résultat :
Je suis une méthode statique
Redéfinition de méthode afficher 18
▪ Un moyen d’écrire du code générique
▪ Une solution au problème de l’héritage multiple
▪ Un outil pour concevoir des applications réutilisables

19