Guide du débutant sur l’utilisation des interfaces en Java

Une interface est un type de référence utilisé pour appliquer un contrat avec une classe. Un contrat fait référence à une obligation de mettre en œuvre les méthodes définies par une interface.

Les interfaces fournissent une abstraction entre les méthodes qu'elles définissent et comment l'utilisateur les implémente dans une classe. Un cas d'utilisation pratique de ceci est dans les API (interfaces de programmation d'applications).

Les API permettent à votre programme de communiquer avec d'autres programmes sans savoir comment ils sont implémentés. Ceci est important à la fois pour des raisons de propriété (pour la société qui détient les droits) et pour faciliter le développement de votre part.

Voyons comment utiliser les interfaces Java.

Définition d'interfaces

Pour déclarer une interface, placez le mot clé interface avant le nom de l'interface.

 interface Car{
 // constant declarations, if any
 int tyres = 4;
 // method signatures
 int lights (int brightness);
 int turn (int tyres, String direction){
 // some code
 }
 }

Dans votre entête d'interface, vous pouvez également inclure son niveau de visibilité avant le mot clé interface .

Les valeurs dans une interface sont constantes. Ces valeurs sont par défaut public, static et final . Par conséquent, il n'est pas nécessaire d'utiliser ces mots-clés lors de la déclaration de valeurs dans le corps d'une interface.

Connexe: Comment gérer la portée variable en Java

Le corps d'une interface peut également avoir des méthodes statiques abstraites par défaut . Ces méthodes sont par défaut public , il n'est donc pas nécessaire d'indiquer ces modificateurs d'accès lors de leur déclaration.

Les méthodes abstraites sont déclarées en omettant les accolades du corps d'une méthode. Voir la ligne 7 dans le code ci-dessus. Les méthodes statiques sont déclarées en poursuivant le nom de la méthode avec le mot-clé static & les méthodes par défaut sont déclarées avec le modificateur par défaut .

Ce serait maintenant le bon moment pour mentionner que vous devez utiliser les méthodes déclarées dans une interface dans toutes les classes qui l'implémentent. Ne pas le faire obligera le compilateur à "appliquer le contrat" ​​en donnant une erreur de compilation.

Cette propriété particulière des interfaces peut présenter certains inconvénients. Prenons un cas où un fournisseur d'interfaces de programmation d'applications (API) décide d'ajouter plus de méthodes à leurs interfaces, mais plusieurs applications sont basées sur les anciennes interfaces. Les développeurs utilisant les anciennes interfaces dans leurs programmes devraient réécrire leur code, ce qui n'est pas pratique.

C'est donc là qu'interviennent les méthodes par défaut . Elles permettent aux fournisseurs d'API d'ajouter plus de méthodes à leurs interfaces tout en garantissant la compatibilité binaire avec les anciennes versions d'interface.

 default int getDirection ( String coordinates){
 // write some code to give a default implementation
 }

La méthode ci-dessus montre comment une méthode par défaut appelée getDirection est déclarée. Notez que vous devez inclure une implémentation d'une méthode par défaut lorsque vous l'écrivez.

Utilisation d'interfaces

Maintenant que nous avons défini des interfaces en Java, nous pouvons passer à la façon dont vous pouvez les implémenter. Vous le découvrirez dans la section ci-dessous.

Implémentation d'interfaces

Pour implémenter une interface, utilisez le mot clé implements en utilisant cette syntaxe :

 class A implements interface P{
 }

N'oubliez pas que vous devez utiliser toutes les méthodes d'interface de la classe. Vous ne pouvez ignorer cette règle que si l'une des méthodes est définie par défaut dans l'interface.

Connexes : Introduction à l'utilisation des listes chaînées en Java

Si vous souhaitez que votre classe implémente plusieurs interfaces, vous pouvez les séparer à l'aide de virgules dans votre déclaration d'en-tête.

Exemple:

 class A implements interface P, Q, R{
 }

Si la classe qui implémente l'interface est une sous-classe, utilisez la syntaxe ci-dessous :

 class A extends B implements C, D{
 }

Les interfaces permettent des héritages multiples en Java. Normalement, une classe ne peut étendre qu'une seule classe (héritage unique). Les interfaces sont le seul moyen pour Java d'effectuer plusieurs héritages.

Les interfaces peuvent également étendre d'autres interfaces, tout comme une classe peut étendre une autre classe. L'interface enfant hérite des méthodes de l'interface qu'elle étend.

Voir l'exemple ci-dessous :

 interface A extends B{
 }

Outre l'utilisation de méthodes par défaut pour modifier une interface sans demander aux développeurs de modifier leurs programmes actuels, vous pouvez également étendre les interfaces existantes.

Vous avez maintenant des connaissances de base sur les interfaces Java

Les interfaces en Java démontrent l'abstraction, l'un des quatre piliers de la programmation orientée objet. Le polymorphisme est l'un de ces quatre piliers. Il fait référence à la capacité d'une méthode à prendre plusieurs formes.

Vous pouvez implémenter le polymorphisme en Java via la surcharge de méthode ou le remplacement de méthode. La prochaine étape de votre liste de lecture Java devrait être de savoir comment implémenter ces fonctions.