Java - Interfaces

Bienvenue, émerveillés programmeurs ! Aujourd'hui, nous allons plonger dans le monde fascinant des interfaces Java. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je vais vous guider à travers ce concept étape par étape, tout comme j'ai fait pour d'innombrables étudiants au fil des années. Alors, prenez votre boisson préférée, mettez-vous à l'aise, et partons ensemble dans cette aventure passionnante !

Java - Interfaces

Qu'est-ce qu'une interface Java ?

Imaginez que vous construisez un robot (s'il vous plaît patienter, cette analogie va bientôt avoir du sens !). Vous savez que vous voulez que votre robot fasse certaines choses, comme se déplacer et faire du bruit, mais vous ne savez pas encore exactement comment il le fera. En Java, une interface est comme un plan pour votre robot. Elle définit ce que votre robot devrait être capable de faire, sans spécifier comment il le fera.

En termes de programmation, une interface est un contrat qui spécifie un ensemble de méthodes abstraites que une classe doit implémenter. C'est un moyen d'atteindre l'abstraction et de définir un comportement commun que plusieurs classes peuvent partager.

Déclarer une interface en Java

Commençons par un exemple simple. Voici comment nous déclarons une interface :

public interface Robot {
void move();
void makeSound();
}

Dans cet exemple, nous avons déclaré une interface appelée Robot avec deux méthodes abstraites : move() et makeSound(). Notez que ces méthodes n'ont pas de corps - ce sont juste des déclarations. Il revient aux classes qui implémentent cette interface de fournir le code réel pour ces méthodes.

Propriétés des interfaces Java

Avant de poursuivre, résumons rapidement certaines propriétés clés des interfaces Java :

Toutes les méthodes dans une interface sont implicitement publiques et abstraites.
Les interfaces ne peuvent pas être instanciées directement.
Une interface peut étendre plusieurs interfaces.
Les variables dans une interface sont implicitement publiques, statiques et finales.

Implémenter des interfaces en Java

Maintenant que nous avons notre interface Robot, créons une classe qui l'implémente. Nous appellerons cette classe AndroidRobot :

public class AndroidRobot implements Robot {
@Override
public void move() {
System.out.println("Android robot marche sur deux jambes.");
}

@Override
public void makeSound() {
System.out.println("Android robot dit : 'Bonjour, humain !'");
}
}

Ici, nous avons utilisé le mot-clé implements pour indiquer que notre classe AndroidRobot implémente l'interface Robot. Nous fournissons ensuite des implémentations pour les méthodes move() et makeSound().

Analysons cela :

L'annotation @Override est optionnelle mais recommandée. Elle informe le compilateur que nous avons intentionnellement redéfini une méthode de l'interface.
Nous avons donné des implémentations spécifiques à move() et makeSound(). Notre robot Android marche sur deux jambes et peut dire bonjour !

Utiliser notre interface et notre classe

Maintenant, voyons comment nous pouvons utiliser notre nouvelle interface et classe :

public class RobotDemo {
public static void main(String[] args) {
Robot myRobot = new AndroidRobot();
myRobot.move();
myRobot.makeSound();
}
}

Lorsque nous exécutons ce code, nous verrons :

Android robot marche sur deux jambes.
Android robot dit : 'Bonjour, humain !'

Notez comment nous avons déclaré myRobot comme de type Robot (l'interface) mais l'avons instancié comme un AndroidRobot. C'est une fonctionnalité puissante des interfaces - nous pouvons programmer pour l'interface, pas pour l'implémentation. Cela rend notre code plus flexible et plus facile à modifier à l'avenir.

Étendre les interfaces Java

Tout comme les classes, les interfaces peuvent étendre d'autres interfaces. Cela nous permet de créer des interfaces plus spécialisées. Créons une interface de robot plus avancée :

public interface AdvancedRobot extends Robot {
void fly();
void swim();
}

Maintenant, toute classe qui implémente AdvancedRobot doit fournir des implémentations pour move(), makeSound(), fly() et swim().

Héritage multiple avec les interfaces

Contrairement aux classes, qui ne peuvent étendre qu'un seul superclass, une interface peut étendre plusieurs interfaces. C'est ainsi que Java fournit une forme d'héritage multiple. Voici un exemple :

public interface Flying {
void takeOff();
void land();
}

public interface Swimming {
void dive();
void surface();
}

public interface AmphibiousRobot extends Robot, Flying, Swimming {
void transformMode();
}

Une classe implémentant AmphibiousRobot devrait fournir des implémentations pour toutes les méthodes de Robot, Flying, Swimming et AmphibiousRobot.

Méthodes par défaut dans les interfaces

Depuis Java 8, les interfaces peuvent avoir des méthodes par défaut - des méthodes avec une implémentation par défaut. Cette fonctionnalité a été introduite pour permettre l'ajout de nouvelles méthodes aux interfaces sans casser les implémentations existantes. Voici un exemple :

public interface ModernRobot {
void process();

default void boot() {
System.out.println("Démarrage...");
process();
System.out.println("Démarrage terminé !");
}
}

Les classes implémentant ModernRobot doivent implémenter process(), mais elles obtiennent boot() gratuitement. Elles peuvent redéfinir boot() si elles le veulent, mais elles n'ont pas besoin de le faire.

Interfaces fonctionnelles

Une interface fonctionnelle est une interface qui contient exactement une méthode abstraite. Ce sont importantes pour les expressions lambda de Java. Voici un exemple :

@FunctionalInterface
public interface Calculator {
int calculate(int a, int b);
}

Nous pouvons utiliser cette interface avec une expression lambda comme ceci :

Calculator add = (a, b) -> a + b;
System.out.println(add.calculate(5, 3));  // Sortie : 8

Conclusion

Whew ! Nous avons couvert beaucoup de terrain aujourd'hui. De la déclaration d'interface de base aux interfaces fonctionnelles, vous avez maintenant une base solide sur les interfaces Java. N'oubliez pas, les interfaces sont un outil puissant dans la programmation Java. Elles permettent de définir un comportement commun, d'atteindre une forme d'héritage multiple et d'écrire un code plus flexible et plus facile à entretenir.

Au fur et à mesure de votre parcours Java, vous découvrirez des interfaces partout. Elles sont largement utilisées dans les bibliothèques standard de Java et dans de nombreux modèles de conception. Alors, continuez à pratiquer, et bientôt, vous serez à interfacer comme un pro !

Bon codage, futurs maîtres Java ! ??‍??‍?

Credits: Image by storyset