Implémente en Java

Lorsque certains parlent du paradigme d'héritage Java OOP, ils signifient généralement l'extension d'une classe parent avec un héritier, une classe enfant. Cependant, lorsque vous rencontrez le mot-clé Java implements, cela signifie que nous passons à un autre niveau d'abstraction et que nous commençons à travailler avec les interfaces en Java. Nous allons parler de ce que sont les interfaces, à quoi elles servent, comment se passe la mise en œuvre.

Qu'est-ce que l'interface et l'implémentation

Vous avez probablement entendu le mot « interface » plusieurs fois. Par exemple, un ordinateur a une interface d'entrée (souris et clavier), de nombreux programmes ont des interfaces utilisateur. Au sens le plus large, une interface est un lien entre deux parties en interaction. Par exemple, le même clavier ou la télécommande du téléviseur. En programmation, et en Java en particulier, une interface est un contrat spécifique qui dit ce que fera la classe qui l'implémente. Une interface ne définit que le comportement. Il ne dit rien sur l'objet qui l'implémentera. Vous pouvez déclarer une interface en Java comme ceci :

public interface MyInterface  {

     // constants declaration 
     // methods without implementation
     // static methods
     // default methods (default)
     // private methods
}

Voici une syntaxe d' Implements en Java :

public class MyClass implements MyInterface{
//implementing the methods of MyInterface 
//Other code
} 

Une interface décrit un comportement sans le spécifier. Par exemple, un comportement tel que "mouvement" peut être appliqué à différents types d'objets : un vélo, une personne, une voiture, de l'eau dans une rivière, etc. Le comportement de nage peut être celui d'un canard, d'un bateau ou d'un poisson. Ces objets n'ont rien en commun si ce n'est qu'ils peuvent bouger ou nager. Oui, et le mouvement même avec la natation est très différent. Cependant, en Java, vous pouvez créer des classes Duck , Boat , Fish et les laisser implémenter la capacité de nager. C'est là que le mot-clé Java Implements est utilisé.

Implémenter le mot-clé Exemple

public interface Swimmable {
  
   void moveForward();
   void TurnRight();
   void TurnLeft();
  
}

Comme vous pouvez le voir, les méthodes elles-mêmes ne sont pas implémentées. Mais nous avons déclaré que les classes qui implémentent cette interface doivent pouvoir nager en ligne droite, ainsi que tourner à droite et à gauche. Créons des classes qui implémenteront cette interface.

public class Duck implements Swimmable {
//implementing the methods
   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

}

public class Fish implements Swimmable {

   public void moveForward() {
       System.out.println("I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft() {
       System.out.println("I am turning left...");
   }

   public void turnUp(){
       System.out.println("I am turning up...");
   }

   public void turnDown(){
       System.out.println("I am turning down...");
   }

   public void Stop() {
       System.out.println("I am relaxing somewhere under the water surface...");
   }
}

Toutes les classes qui implémentent l' interface Swimmable , selon le contrat, doivent pouvoir nager vers l'avant (implémenter la méthode moveForward() ), ainsi que tourner à droite et à gauche. La mise en œuvre de ces méthodes est nécessaire. Un canard et un poisson nagent différemment. Disons qu'un poisson a deux méthodes supplémentaires qui implémentent sa capacité à nager de haut en bas. L'interface Swimmable n'a pas cela. Cependant, si nous créons un enfant de la classe Poisson, par exemple, Thon ou Saumon, ils, comme tous les "Poissons", pourront nager de haut en bas.

Interfaces multiples en Java

Comme vous le savez probablement déjà, Java ne prend pas en charge l'héritage multiple. Cela signifie qu'une classe ne peut être héritée que d'une seule superclasse. Cependant, d'une certaine manière, vous pouvez toujours utiliser «l'héritage multiple» en Java, car une classe peut implémenter plusieurs interfaces.

To implement multiple interfaces, use the next syntax: 
interface MyFirstInterface {
   public void myMethod();
}
interface MySecondInterface {
   public void myOtherMethod();
}

// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
   public void myMethod() {
      //method implementation
   }
   public void myOtherMethod() {
     //method implementation
   }
}

Exemple d'interfaces multiples

Rappelez-vous qu'un canard peut non seulement nager, mais aussi voler. Écrivons l'interface de vol et implémentons-la dans notre canard.

public interface Flyable {
   double startAge = 0.1;
   void fly();
}

public class Duck implements Swimmable, Flyable {

   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

   public void fly(){
       System.out.println("I am flying!!!");
   }

}

Et encore une fois, il est important de se rappeler pourquoi nous écrivons l'interface. Disons que s'il est mis en œuvre par un oiseau, un avion, un parachutiste et un pissenlit, leurs vols seront complètement différents.