En Java, les interfaces sont essentielles lorsqu'il s'agit de définir des contrats de classe et de garantir la cohérence du code dans le domaine de la programmation Java. Il sert de modèle de classe en décrivant un certain nombre de méthodes que la classe d'implémentation doit implémenter. L'abstraction, la modularité et la maintenabilité de leur code peuvent toutes être réalisées par les développeurs en utilisant des interfaces. Le différents types d'interfaces en Java seront abordés dans cette section.

Interfaces de marqueurs

Les interfaces de marqueur, souvent appelées interfaces de balises, sont des interfaces sans aucune méthode déclarée. En termes simples, ils servent de marqueurs, signalant qu'une classe qui implémente l'interface de marqueur possède des propriétés ou des qualités particulières. L'environnement d'exécution Java et d'autres outils utilisent ces API pour fournir des fonctionnalités ou des données supplémentaires. Sérialisable, Cloneable et Remote sont quelques instances d'interfaces de marqueur en Java.

Interfaces fonctionnelles

Dans le cadre des améliorations apportées aux expressions lambda et à la programmation fonctionnelle, des interfaces fonctionnelles ont été ajoutées à Java 8. Une interface qui possède précisément une méthode abstraite est dite fonctionnelle. De plus, des méthodes par défaut et statiques sont possibles. De nombreuses fonctionnalités de programmation fonctionnelle Java, telles que les expressions lambda et les références de méthodes, utilisent des interfaces fonctionnelles. Prédicat, Consommateur, Fonction et Fournisseur ne sont que quelques-unes des interfaces fonctionnelles intégrées proposées par le package java.util.function.

Interfaces de méthode abstraite unique (SAM)

Avant Java 8, il existait certains types d'interfaces fonctionnelles appelées interfaces SAM. Ces interfaces peuvent avoir un nombre illimité de méthodes par défaut ou statiques, mais une seule méthode abstraite. Runnable, Comparator et MouseListener sont quelques API pré-Java 8 qui contiennent des exemples d'interface SAM. Avec l'introduction des interfaces fonctionnelles dans Java 8, les interfaces SAM peuvent être utilisées avec des expressions lambda et considérées comme des interfaces fonctionnelles.

programme python pour la recherche binaire

Interfaces normales

Le type d’interface le plus répandu en Java est celui des interfaces normales. Ils disposent d'une ou plusieurs méthodes abstraites que les classes qui implémentent l'interface doivent implémenter. À partir de Java 8, les interfaces normales peuvent en outre contenir des méthodes par défaut et statiques. Les interfaces normales sont utilisées par les développeurs pour spécifier les règles ou exigences que les classes doivent suivre. List, Set et Map, qui se trouvent tous dans le package java.util, sont des exemples d'interfaces Java typiques.

Interfaces d'héritage multiples

Java permet aux classes d'implémenter plusieurs interfaces mais ne prend pas en charge l'héritage de plusieurs classes. Les interfaces implémentées par une classe pour définir simultanément de nombreux contrats ou hériter de comportements sont appelées interfaces d'héritage multiple. Une classe peut offrir les fonctionnalités décrites par chaque interface en implémentant plusieurs interfaces. Avec l'aide de cette fonctionnalité, les développeurs peuvent réutiliser le code et augmenter l'adaptabilité de leurs idées.

Voici des exemples de code pour chaque type d’interface en Java ainsi que leur sortie correspondante :

Interfaces de marqueurs

MarkerInterfaceExample.java

 import java.io.Serializable; // Marker Interface interface MyMarkerInterface extends Serializable { } public class MarkerInterfaceExample { public static void main(String[] args) { MyMarkerInterface obj = new MyMarkerInterface() { }; System.out.println(obj instanceof Serializable); // true } } 

Sortir:

sélection de plusieurs tables SQL

 true 

Interfaces fonctionnelles

FunctionalInterfaceExample.java

 import java.util.function.Predicate; public class FunctionalInterfaceExample { public static void main(String[] args) { Predicate isLengthGreaterThan5 = str -> str.length() > 5; System.out.println(isLengthGreaterThan5.test('Hello')); // false System.out.println(isLengthGreaterThan5.test('OpenAI')); // true } } 

Sortir:

 false true 

Interfaces de la méthode abstraite unique (SAM) :

SAMInterfaceExample.java

 interface MySAMInterface { void performAction(); } public class SAMInterfaceExample { public static void main(String[] args) { MySAMInterface obj = () -> System.out.println('Performing action'); obj.performAction(); // Performing action } } 

Sortir:

qu'est-ce que la soumission d'annuaire

 Performing action 

Interfaces normales

NormalInterfaceExample.java

 import java.util.List; import java.util.ArrayList; interface MyInterface { void printMessage(); } class MyClass implements MyInterface { @Override public void printMessage() { System.out.println('Hello, World!'); } } public class NormalInterfaceExample { public static void main(String[] args) { MyInterface obj = new MyClass(); obj.printMessage(); // Hello, World! } } 

Sortir:

types de données Java

 Hello, World! 

Interfaces d'héritage multiples :

MultipleInheritanceInterfaceExample.java

 interface Interface1 { void method1(); } interface Interface2 { void method2(); } class MyClass implements Interface1, Interface2 { @Override public void method1() { System.out.println('Method 1'); } @Override public void method2() { System.out.println('Method 2'); } } public class MultipleInheritanceInterfaceExample { public static void main(String[] args) { MyClass obj = new MyClass(); obj.method1(); // Method 1 obj.method2(); // Method 2 } } 

Sortir:

 Method 1 Method 2 

Ces exemples démontrent l'utilisation et le comportement de différents types d'interfaces en Java. Vous pouvez exécuter chaque extrait de code individuellement pour observer la sortie correspondante.

En conclusion, les interfaces Java offrent une méthode puissante pour spécifier des contrats et atteindre la modularité du code. Les interfaces sont essentielles au développement Java, qu'il s'agisse d'interfaces de marqueurs indiquant des traits spécifiques, d'interfaces fonctionnelles permettant la programmation fonctionnelle, d'interfaces régulières définissant des contrats ou d'interfaces d'héritage multiples combinant plusieurs contrats. Les développeurs Java sont mieux équipés pour créer un code clair et extensible lorsqu'ils connaissent les différents types d'interface et leurs fonctions.