Interface en Java

Comme vous le savez, tout en Java est constitué d'objets, et les objets ont un état (champs) et un comportement (défini par des méthodes). Le comportement d’une classe est ce qui peut la lier aux autres classes. Le comportement peut avoir différentes caractéristiques et il peut parfois être plus pratique de le déplacer en dehors de la classe, notamment lorsqu'il s'agit d'interagir avec le monde extérieur. Tout comme la télécommande du téléviseur se trouve en dehors de la « boîte » elle-même. La télécommande est une interface permettant à l'utilisateur d'interagir avec les fonctions du téléviseur. Par exemple, vous pouvez imaginer une classe qui implémente un avion ou un hélicoptère abstrait. Les objets des deux classes, comme la plupart des oiseaux, peuvent voler, et ils le font tous différemment. Peut-être vaut-il la peine de déplacer cette fonctionnalité dans une entité distincte, et tous les « flyers » potentiels seront hérités de cette entité ? Si vous êtes déjà familier avec les classes abstraites, vous pouvez simplement créer une classe abstraite Flyable et en « hériter » les classes Copter et Plane. Cependant, que se passe-t-il s’il existe plusieurs de ces propriétés ? Par exemple, les avions et les hélicoptères peuvent voler, mais aussi voyager au sol. Même si nous créons la classe Ride, nous ne pouvons plus lui attribuer Copter et Plane. Après tout, chaque classe Java n’a qu’une seule classe parent. L'utilisation d'interfaces en langage Java résout partiellement ce problème. Les interfaces en Java définissent certaines fonctionnalités qui n'ont pas d'implémentation spécifique, qui sont ensuite implémentées par les classes qui utilisent ces interfaces. Et une classe peut implémenter plusieurs interfaces. En fait, en implémentant une interface en Java, on déclare que notre classe peut faire quelque chose, on rapporte son comportement. Nous effectuons déjà la mise en œuvre concrète du comportement en classe. Donc. un avion et un hélicoptère décollent différemment : un avion a besoin d'une piste, tandis qu'un hélicoptère décolle généralement verticalement. Ces détails sont mieux mis en œuvre au sein de la classe.

Interfaces en Java

Pour définir une interface en langage Java, le mot clé interface est utilisé. Par exemple:

interface Voice {

    void talk();
}

L'interface ci-dessus s'appelle Voice . Une interface en Java peut définir des constantes et des méthodes, qui peuvent ou non avoir des implémentations. Habituellement, les méthodes d'interface n'ont pas d'implémentation, tout comme dans cet exemple. Les méthodes dans les interfaces sans implémentation sont comme les méthodes abstraites des classes abstraites. Les méthodes d'interface n'ont généralement pas de modificateurs d'accès. Cependant, l'accès est en réalité public par défaut car le but d'une interface est de définir des fonctionnalités pour une implémentation de classe. Par conséquent, toutes les fonctionnalités doivent être ouvertes à la mise en œuvre. Pour implémenter une interface, utilisez le mot-clé Implements lors de la déclaration de votre classe. De plus, si une interface contient une méthode sans implémentation, alors cette méthode doit être implémentée dans la classe d'implémentation.

public class Duck implements Voice {


@Override
public void voice() {
   System.out.println("Quack");
}


    }

Exemple de code d'interface

Prenons un exemple plus complet. Chaque (enfin, presque tous) animal a la capacité d’émettre des sons. Créons une interface Java Voice pour ce cas. Il a une méthode talk() sans implémentation.

public interface Voice {
   void talk();
}

Désormais, toutes les classes prenant en charge l' interface Voice doivent avoir une implémentation de la méthode talk() . Créons deux classes — Cat et Dog et indiquons qu'elles implémentent l' interface Voice . Dans ce cas, si vous n’y implémentez pas de classe, le programme ne fonctionnera pas. Les méthodes de mise en œuvre sont très simples. Lors de l'appel de la méthode talk() d'un objet de la classe Cat , l'équivalent texte d'un miaou sera affiché à l'écran, dans le cas de la classe Dog , un aboiement. Nous ajouterons également des getters, des setters et un constructeur aux classes.

public class Cat implements Voice {
   String name;
   String breed;
   int year;

   public Cat(String name, String breed, int year) {
       this.name = name;
       this.breed = breed;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getBreed() {
       return breed;
   }

   public void setBreed(String breed) {
       this.breed = breed;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("meow...");
   }
}

public class Dog implements Voice {
   String name;
   String color;
   int year;

   public Dog(String name, String color, int year) {
       this.name = name;
       this.color = color;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("WOF WOF");
   }
}

En fait, nos implémentations de classes et de méthodes sont très similaires. Créons une autre classe, Parrot , avec le support Voice . Seule la méthode talk() y fonctionnera différemment : l'utilisateur entrera une chaîne dans la console et le perroquet la « répétera » en utilisant la méthode talk() .

import java.util.Scanner;

public class Parrot implements Voice {
   String name;
   String color;
   int year;

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       Scanner scanner = new Scanner(System.in);
       System.out.println("WHat should I repeat after you?...");
       String s =  scanner.nextLine();
       System.out.println(s);
   }
}

Créons maintenant une classe de test et voyons quel résultat le programme produira si nous appelons tour à tour la méthode talk() des objets des classes Cat , Dog et Parrot .

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Parrot parrot = new Parrot();
       parrot.talk();
   }
}

La sortie est ci-dessous. Le texte vert est celui de l'utilisateur imprimé dans la console.

Méthodes par défaut

Avant la version JDK 8, lors de l'implémentation d'une interface en Java, nous devions implémenter toutes ses méthodes dans une classe. Dans le même temps, l'interface Java elle-même ne pouvait contenir que des définitions de méthodes sans implémentation spécifique. JDK 8 ajoute de nouvelles fonctionnalités : les méthodes par défaut. Désormais, les interfaces Java peuvent avoir non seulement des définitions de méthodes, mais également des implémentations par défaut. Ils sont utilisés si la classe implémente l'interface mais n'implémente pas la méthode. Par exemple, modifions la méthode talk() dans l' interface Voice par la méthode par défaut. Nous allons également écrire une nouvelle classe Duck compatible Voice qui n'a pas d'implémentation de la méthode talk .

public interface Voice {
   default void talk() {
       System.out.println("I can talk...");
   }
}

public class Duck implements Voice {

   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!!!");
   }

}

Modifions maintenant un peu notre classe de test.

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Duck duck = new Duck();
       duck.talk();
   }
}

Le résultat est ici : Voir? Dans les objets des classes Dog et Cat , la méthode substituée talk() est appelée, mais dans un objet de la classe Duck , la méthode par défaut de l'interface est appelée. Ainsi, la méthode par défaut est simplement une méthode sans modificateurs et est marquée avec le mot-clé default . Nous n'avons pas besoin d'implémenter la méthode par défaut dans la classe qui implémente l'interface, mais nous pouvons la remplacer.

Méthodes statiques

Étant donné que les méthodes statiques du JDK 8 sont disponibles dans les interfaces Java, elles sont similaires aux méthodes de classe :

interface Voice {

    void talk();

    static void check(){

        System.out.println("checked...");
    }
}

Pour faire référence à une méthode statique d'une interface, comme dans le cas des classes, écrivez le nom de l'interface et de la méthode :

public static void main(String[] args) {

    Voice.check();
}

Implémentation multiple d'interfaces

Si nous devons appliquer plusieurs interfaces dans la classe Java, alors elles sont toutes répertoriées avec une virgule après le mot Implements :

public class Duck implements Swimmable, Flyable, Voice {

    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!!!");
    }

}