Les interfaces

Changement au diagramme

classDiagram
    Animal <|-- Chien
    Animal <|-- Chat

    Personne <|-- Etudiant

    class Animal{
        String nom
        String espece

        Animal(nom, espece)
        marcher()
    }

    class Chien{
        jappe()
    }
    class Chat {
        miaule()
    }

    class Personne {
        String nom
        Integer age
        marcher()
    }

    class Etudiant {
        String noEtudiant
    }

On peut se rendre compte qu'une personne et qu'un étudiant peut également marcher. Peut-être de manière différentes, mais ils peuvent marcher tout de même. Si on voulait reprendre l'exemple de polymorphisme précédent, on ne pourrait pas, car les classes Personne et Animal n'ont rien en commun. Il nous faudrait plusieurs listes et plusieurs boucles.

Le type Interface

Les interfaces sont des contrats indiquant les actions que doivent posséder certains objets. Ils n'indiquent pas la manière de s'y prendre, mais bien qu'ils doivent pouvoir effectuer ces actions.

Dans l'exemple précédent, la méthode marche() est commune pour les animaux et les personnes. On pourrait alors la transformer en interface et forcer les objets à gérer ces méthodes.

IMarche.java

public interface IMarche {
    public void marcher();
}

Animal.java

public abstract class Animal implements IMarche {
    // [...]

    @Override
    public void marcher() {
        System.out.println("Je suis un animal et je marche");
    }

    // [...]
}

La même chose serait faite pour les personnes. Finalement, l'interface peut également servir à boucler comme précédemment :

ArrayList<IMarche> marcheurs = new ArrayList<>();
marcheurs.addAll(personnes);
marcheurs.addAll(animaux);

for (IMarche marcheur : marcheurs) {
    marcheur.marcher();
}

Quelques exemples d'utilisation d'une interface

Voici quelques exemples qui peuvent aider à comprendre les interfaces :

• IExportable -> Permet d'exporter l'objet vers un fichier. On ne spécifie pas la façon de faire ni le format, seulement qu'il peut être exporté.
• IDessinable, IDeplacable -> Permet à l'objet d'être dessiné ou déplacé à l'écran. On n'indique pas le dessin à utiliser ni la méthode pour se déplacer, seulement que c'est possible.
• IArchivable -> Permet d'archiver l'instance. Il peut y avoir différentes règles d'archivage qui s'appliquent à des types différents.