Les interfaces en Java simplement
Tags: java, programmation, poo, interfaces
Published: 2023-03-08 17:22:10

En programmation orientée objet (POO), une **interface** est un **type de contrat qui définit les méthodes qu'une classe doit implémenter**. Une interface ne fournit **pas d'implémentation** réelle des méthodes, mais elle fournit simplement une **liste de méthodes** que la classe qui implémente l'interface doit fournir.

En Java, le mot-clé "**implements**" est utilisé pour indiquer qu'une **classe implémente une interface**. Cela signifie que la classe fournit une implémentation pour toutes les méthodes définies dans l'interface. 
En POO, l'**implémentation** fait référence au **code concret** qui fournit une **fonctionnalité** spécifique définie dans une interface, une classe abstraite ou une superclasse. Nous aurons l'occasion d'évoquer les deux dernières. Pour le moment, nous nous concentrons sur les interfaces uniquement.

Voici un exemple de déclaration de classe qui implémente une interface en utilisant le mot clé "implements":

```java
public class MyClass implements MyInterface {

// Code de la classe

}
```
Dans cet exemple, "MyClass" est une classe qui implémente l'interface "MyInterface". La classe doit fournir des implémentations pour toutes les méthodes définies dans "MyInterface".

En Java, une interface est définie à l'aide du mot-clé "**interface**". Les **classes** qui implémentent une interface doivent fournir une **implémentation** pour toutes les **méthodes de l'interface**. Une **classe peut implémenter plusieurs interfaces**, ce qui permet à la classe d'avoir plusieurs types.

Voici un exemple d'interface en Java :

```java
public interface Animal {

public void makeSound();
public void move();

}
```
Dans cet exemple, nous avons défini une **interface** appelée "**Animal**". L'interface définit deux méthodes, "**makeSound**" et "**move**". Toutes les classes qui implémentent cette interface doivent fournir une implémentation pour ces deux méthodes.

Voici un exemple de classe qui implémente l'interface "Animal" :
```java
public class Dog implements Animal {

public void makeSound() {
System.out.println("Woof!");
}

public void move() {
System.out.println("The dog is running.");
}

}
```
Dans cet exemple, nous avons défini une classe appelée "**Dog**" qui implémente l'interface "**Animal**". La **classe** fournit une **implémentation** pour les méthodes "**makeSound**" et "**move**". La méthode "makeSound" affiche "Woof!" et la méthode "move" affiche "The dog is running.".

Nous pouvons également créer une autre classe qui implémente l'interface "Animal". Par exemple :
```java
public class Cat implements Animal {

public void makeSound() {
System.out.println("Meow!");

}

public void move() {
System.out.println("The cat is running.");
}

}
```
Dans cet exemple, nous avons défini une **classe** appelée "**Cat**" qui implémente également l'interface "**Animal**". La classe fournit une implémentation pour les méthodes "**makeSound**" et "**move**". La méthode "makeSound" affiche "Meow!" et la méthode "move" affiche "The cat is running.".

Maintenant, nous pouvons utiliser ces deux classes comme des objets de type "Animal". Par exemple :
```java
Animal myDog = new Dog();
Animal myCat = new Cat();

myDog.makeSound(); // affichera "Woof!"
myCat.makeSound(); // affichera "Meow!"
```

Dans cet exemple, nous avons créé **deux objets**, "**myDog**" et "**myCat**", de **type** "**Animal**". Nous avons ensuite appelé la méthode "**makeSound**" sur chacun de ces objets. Lorsque nous avons appelé "**myDog.makeSound()**", il a affiché "Woof!", et lorsque nous avons appelé "**myCat.makeSound()**", il a affiché "Meow!".

Ici j'aimerais ouvrir une petite parenthése qui me semble importante. Nous créons une **nouvelle instance de la classe** "**Dog**" (et non de la classe "Animal") en utilisant l'opérateur "**new**" et nous la stockons dans une variable de **type** "**Animal**".

```java
Animal myDog = new Dog();
```
En utilisant cette approche, nous pouvons **manipuler l'objet "Dog" en tant qu'objet "Animal"**.

Cependant, il est important de noter que même si "**myDog**" est référencé par une variable de type "Animal", il **conserve toujours ses propriétés et son comportement de "Dog"**.

Les interfaces sont utiles dans de nombreuses situations, notamment lors de la création de bibliothèques de classes qui doivent être utilisées par d'autres développeurs. En utilisant des interfaces, les développeurs peuvent **garantir que toutes les classes qui implémentent l'interface ont des méthodes spécifiques**, ce qui facilite la création de programmes qui utilisent ces classes.