Interface en Java

Interface en java est l’un des concepts fondamentaux. L’interface Java est une partie essentielle du langage de programmation Java et est largement utilisée non seulement dans le JDK, mais aussi dans les modèles de conception Java. La plupart des frameworks utilisent intensivement l’interface java.

Interface en Java

L’interface en java offre une façon d’atteindre l’abstraction. L’interface Java est également utilisée pour définir le contrat que les sous-classes doivent implémenter. Par exemple, supposons que nous voulions créer un dessin composé de plusieurs formes. Ici, nous pouvons créer une interface Shape et définir toutes les méthodes que différents types d’objets Shape implémenteront. À des fins de simplicité, nous pouvons ne conserver que deux méthodes – draw() pour dessiner la forme et getArea() qui renverra la superficie de la forme.

Exemple d’interface Java

En fonction des exigences ci-dessus, notre interface Shape ressemblera à ceci. Shape.java

package com.journaldev.design;

public interface Shape {

	//implicitly public, static and final
	public String LABLE="Shape";
	
	//les méthodes d'interface sont implicitement abstraites et publiques
	void draw();
	
	double getArea();
}

Points Importants sur les Interfaces en Java

1. interface est le code utilisé pour créer une interface en Java.

2. On ne peut pas instancier une interface en Java.

3. L’interface fournit une abstraction absolue, dans le dernier article, nous avons appris sur les classes abstraites en Java pour fournir une abstraction, mais les classes abstraites peuvent avoir des implémentations de méthode tandis que les interfaces ne le peuvent pas.

4. Les interfaces ne peuvent pas avoir de constructeurs car on ne peut pas les instancier, et les interfaces ne peuvent pas avoir de méthode avec un corps.

5. Par défaut, tout attribut de l’interface est public, statique et final, donc nous n’avons pas besoin de fournir de modificateurs d’accès aux attributs mais si nous le faisons, le compilateur ne s’en plaint pas non plus.

6. Par défaut, les méthodes de l’interface sont implicitement abstraites et public, cela a un sens total car la méthode n’a pas de corps et ainsi les sous-classes peuvent fournir l’implémentation de la méthode.

7. Une interface ne peut pas étendre une classe mais elle peut étendre une autre interface. public interface Shape extends Cloneable{} est un exemple d’une interface étendant une autre interface. En fait, Java offre l’héritage multiple dans les interfaces, ce qui signifie qu’une interface peut étendre plusieurs interfaces.

8. Le mot-clé implements est utilisé par les classes pour implémenter une interface.

9. Une classe implémentant une interface doit fournir une implémentation pour toutes ses méthodes à moins qu’il ne s’agisse d’une classe abstraite. Par exemple, nous pouvons implémenter l’interface ci-dessus dans une classe abstraite comme ceci: ShapeAbs.java

   package com.journaldev.design;
   
   public abstract class ShapeAbs implements Shape {
   
   	@Override
   	public double getArea() {
   		// TODO Auto-generated method stub
   		return 0;
   	}
   
   }
   

10. Nous devrions toujours essayer d’écrire des programmes en termes d’interfaces plutôt que d’implémentations afin de savoir à l’avance que les classes d’implémentation fourniront toujours l’implémentation et que dans le futur, si une meilleure implémentation arrive, nous pouvons facilement basculer vers celle-ci.

Exemple d’implémentation d’interface Java

Jetons maintenant un coup d’œil à quelques implémentations de notre interface Shape en java. Circle.java

package com.journaldev.design;

public class Circle implements Shape {

	private double radius;

	public Circle(double r){
		this.radius = r;
	}
	
	@Override
	public void draw() {
		System.out.println("Drawing Circle");
	}
	
	@Override
	public double getArea(){
		return Math.PI*this.radius*this.radius;
	}

	public double getRadius(){
		return this.radius;
	}
}

Remarquez que la classe Circle a implémenté toutes les méthodes définies dans l’interface et elle a aussi certaines de ses propres méthodes comme getRadius(). Les implémentations d’interface peuvent avoir plusieurs types de constructeurs. Voyons une autre implémentation d’interface pour l’interface Shape. Rectangle.java

package com.journaldev.design;

public class Rectangle implements Shape {

	private double width;
	private double height;
	
	public Rectangle(double w, double h){
		this.width=w;
		this.height=h;
	}
	@Override
	public void draw() {
		System.out.println("Drawing Rectangle");
	}

	@Override
	public double getArea() {
		return this.height*this.width;
	}

}

Remarquez l’utilisation de l’annotation d’override, apprenez-en davantage sur les annotations en Java et pourquoi nous devrions toujours utiliser l’annotation d’override lors du remplacement d’une méthode en Java. Voici un programme de test montrant comment coder en termes d’interfaces et non d’implémentations. ShapeTest.java

package com.journaldev.design;

public class ShapeTest {

	public static void main(String[] args) {
		
		// programmation pour les interfaces et non pour les implémentations
		Shape shape = new Circle(10);
		
		shape.draw();
		System.out.println("Area="+shape.getArea());
		
		// passer facilement d'une implémentation à une autre
		shape=new Rectangle(10,10);
		shape.draw();
		System.out.println("Area="+shape.getArea());
		}

}

La sortie du programme d’exemple d’interface Java ci-dessus est :

Drawing Circle
Area=314.1592653589793
Drawing Rectangle
Area=100.0

Avantages des interfaces Java

1. L’interface fournit un contrat pour toutes les classes d’implémentation, il est donc bon de coder en termes d’interfaces car les classes d’implémentation ne peuvent pas supprimer les méthodes que nous utilisons.
2. Les interfaces sont bonnes pour définir le type et créer une hiérarchie de niveau supérieur dans notre code.
3. Étant donné qu’une classe Java peut implémenter plusieurs interfaces, il est préférable d’utiliser des interfaces comme super classe dans la plupart des cas.

Inconvénients de l’interface Java

Bien que les interfaces offrent de nombreux avantages, elles présentent également certains inconvénients.

1. Nous devons choisir les méthodes d’interface très soigneusement lors de la conception de notre projet, car nous ne pouvons pas ajouter ou supprimer de méthodes de l’interface ultérieurement. Cela entraînera une erreur de compilation pour toutes les classes d’implémentation. Parfois, cela conduit à avoir de nombreuses interfaces étendant l’interface de base dans notre code, ce qui devient difficile à maintenir.

2. Si les classes d’implémentation ont leurs propres méthodes, nous ne pouvons pas les utiliser directement dans notre code car le type d’objet est une interface qui n’a pas ces méthodes. Par exemple, dans le code ci-dessus, nous obtiendrons une erreur de compilation pour le code shape.getRadius(). Pour surmonter cela, nous pouvons utiliser la conversion de type et utiliser la méthode de cette manière :

   Cercle c = (Cercle) shape;
   c.getRadius();
   

   Bien que la conversion de type de classe ait ses propres inconvénients.

C’est tout ce que j’ai sur l’interface en Java. Comme nous utilisons beaucoup l’interface Java, nous devrions être conscients de ses fonctionnalités. Assurez-vous d’utiliser des interfaces dans la conception du système et comme contrat entre le client et les sous-classes implémentant les interfaces. Mise à jour : Java 8 a modifié la définition des interfaces avec l’introduction des méthodes par défaut et des méthodes statiques. Pour plus de détails, veuillez lire l’interface Java 8.