1. Interface
2. Exemple d'interface
3. Héritage multiple par interface
4. Pourquoi l'héritage multiple est pris en charge dans l'interface alors qu'il n'est pas pris en charge en cas de classe.
5. Interface des marqueurs
6. Interface imbriquée

Un interface en Java est un plan d'une classe. Il possède des constantes statiques et des méthodes abstraites.

L'interface en Java est un mécanisme pour atteindre abstraction . Il ne peut y avoir que des méthodes abstraites dans l'interface Java, pas de corps de méthode. Il est utilisé pour réaliser l'abstraction et de multiples héritage en Java .

En d’autres termes, on peut dire que les interfaces peuvent avoir des méthodes et des variables abstraites. Il ne peut pas avoir de corps de méthode.

Interface Java également représente la relation IS-A .

Elle ne peut pas être instanciée comme la classe abstraite.

Depuis Java 8, on peut avoir méthodes par défaut et statiques dans une interface.

Depuis Java 9, on peut avoir méthodes privées dans une interface.

Pourquoi utiliser l'interface Java ?

Il y a principalement trois raisons d’utiliser l’interface. Ils sont donnés ci-dessous.

• Il est utilisé pour réaliser l’abstraction.
• Par interface, nous pouvons prendre en charge la fonctionnalité d’héritage multiple.
• Il peut être utilisé pour obtenir un couplage lâche.

Comment déclarer une interface ?

Une interface est déclarée à l'aide du mot-clé interface. Il fournit une abstraction totale ; signifie que toutes les méthodes d'une interface sont déclarées avec le corps vide et que tous les champs sont publics, statiques et finaux par défaut. Une classe qui implémente une interface doit implémenter toutes les méthodes déclarées dans l'interface.

Syntaxe:

 interface { // declare constant fields // declare methods that abstract // by default. } 

Amélioration de l'interface Java 8

Depuis Java8 , l'interface peut avoir des méthodes par défaut et statiques qui seront discutées plus tard.

modèle de référence osi en réseau

Ajout interne par le compilateur

Le compilateur Java ajoute des mots-clés publics et abstraits avant la méthode d'interface. De plus, il ajoute des mots-clés publics, statiques et finaux avant les données membres.

En d'autres termes, les champs d'interface sont publics, statiques et finaux par défaut, et les méthodes sont publiques et abstraites.

La relation entre les classes et les interfaces

Comme le montre la figure ci-dessous, une classe étend une autre classe, une interface étend une autre interface, mais une la classe implémente une interface .

Exemple d'interface Java

Dans cet exemple, l'interface Printable n'a qu'une seule méthode, et son implémentation est fournie dans la classe A6.

 interface printable{ void print(); } class A6 implements printable{ public void print(){System.out.println('Hello');} public static void main(String args[]){ A6 obj = new A6(); obj.print(); } } 

Sortir:

 Hello 

Exemple d'interface Java : dessinable

Dans cet exemple, l'interface Drawable n'a qu'une seule méthode. Son implémentation est assurée par les classes Rectangle et Circle. Dans un scénario réel, une interface est définie par quelqu'un d'autre, mais son implémentation est assurée par différents fournisseurs d'implémentation. De plus, il est utilisé par quelqu'un d'autre. La partie implémentation est masquée par l'utilisateur qui utilise l'interface.

Fichier : TestInterface1.java

 //Interface declaration: by first user interface Drawable{ void draw(); } //Implementation: by second user class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class Circle implements Drawable{ public void draw(){System.out.println('drawing circle');} } //Using interface: by third user class TestInterface1{ public static void main(String args[]){ Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable() d.draw(); }} 

Sortir:

 drawing circle 

Exemple d'interface Java : banque

Voyons un autre exemple d'interface Java qui fournit l'implémentation de l'interface Bank.

Fichier : TestInterface2.java

 interface Bank{ float rateOfInterest(); } class SBI implements Bank{ public float rateOfInterest(){return 9.15f;} } class PNB implements Bank{ public float rateOfInterest(){return 9.7f;} } class TestInterface2{ public static void main(String[] args){ Bank b=new SBI(); System.out.println('ROI: '+b.rateOfInterest()); }} 

Sortir:

 ROI: 9.15 

Héritage multiple en Java par interface

Si une classe implémente plusieurs interfaces ou si une interface étend plusieurs interfaces, on parle d'héritage multiple.

 interface Printable{ void print(); } interface Showable{ void show(); } class A7 implements Printable,Showable{ public void print(){System.out.println('Hello');} public void show(){System.out.println('Welcome');} public static void main(String args[]){ A7 obj = new A7(); obj.print(); obj.show(); } } 

 Output:Hello Welcome 

Q) L'héritage multiple n'est pas pris en charge via les classes en Java, mais il est possible par une interface, pourquoi ?

Comme nous l'avons expliqué dans le chapitre sur l'héritage, l'héritage multiple n'est pas pris en charge dans le cas de classe à cause de l'ambiguïté. Cependant, il est pris en charge dans le cas d'une interface car il n'y a pas d'ambiguïté. C'est parce que son implémentation est assurée par la classe d'implémentation. Par exemple:

 interface Printable{ void print(); } interface Showable{ void print(); } class TestInterface3 implements Printable, Showable{ public void print(){System.out.println('Hello');} public static void main(String args[]){ TestInterface3 obj = new TestInterface3(); obj.print(); } } 

Sortir:

 Hello 

Comme vous pouvez le voir dans l'exemple ci-dessus, les interfaces Printable et Showable ont les mêmes méthodes mais son implémentation est fournie par la classe TestTnterface1, il n'y a donc aucune ambiguïté.

Héritage d'interface

Une classe implémente une interface, mais une interface en étend une autre.

 interface Printable{ void print(); } interface Showable extends Printable{ void show(); } class TestInterface4 implements Showable{ public void print(){System.out.println('Hello');} public void show(){System.out.println('Welcome');} public static void main(String args[]){ TestInterface4 obj = new TestInterface4(); obj.print(); obj.show(); } } 

Sortir:

 Hello Welcome 

Méthode par défaut Java 8 dans l'interface

Depuis Java 8, nous pouvons avoir un corps de méthode dans l'interface. Mais nous devons en faire la méthode par défaut. Voyons un exemple :

Fichier : TestInterfaceDefault.java

 interface Drawable{ void draw(); default void msg(){System.out.println('default method');} } class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class TestInterfaceDefault{ public static void main(String args[]){ Drawable d=new Rectangle(); d.draw(); d.msg(); }} 

Sortir:

 drawing rectangle default method 

Méthode statique Java 8 dans l'interface

Depuis Java 8, nous pouvons avoir une méthode statique dans l'interface. Voyons un exemple :

Fichier : TestInterfaceStatic.java

 interface Drawable{ void draw(); static int cube(int x){return x*x*x;} } class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class TestInterfaceStatic{ public static void main(String args[]){ Drawable d=new Rectangle(); d.draw(); System.out.println(Drawable.cube(3)); }} 

Sortir:

 drawing rectangle 27 

Q) Qu'est-ce qu'un marqueur ou une interface balisée ?

Une interface qui n'a aucun membre est appelée interface marqueur ou interface balisée, par exemple : Sérialisable , Clonable, Remote, etc. Ils sont utilisés pour fournir des informations essentielles à la JVM afin que la JVM puisse effectuer certaines opérations utiles.

 //How Serializable interface is written? public interface Serializable{ } 

Interface imbriquée en Java

Remarque : Une interface peut avoir une autre interface appelée interface imbriquée. Nous l'apprendrons en détail dans le classes imbriquées chapitre. Par exemple:

 interface printable{ void print(); interface MessagePrintable{ void msg(); } }