Maîtriser les interfaces Java : concepts, implémentation et bonnes pratiques

Interfaces Java expliquées

Les interfaces Java définissent un contrat que les classes implémentantes doivent honorer. Elles permettent l'abstraction, l'héritage multiple, et favorisent une architecture propre et modulaire.

Définir une interface

Une interface est un type complètement abstrait. Toutes ses méthodes sont implicitement public abstract, et tous ses champs sont public static final. Elle est déclarée avec le mot-clé interface :

interface Language { void getType(); void getVersion(); }

Ici, Language est une interface contenant deux méthodes abstraites.

Implémenter une interface

Les interfaces ne peuvent pas être instanciées. Les classes les implémentent en utilisant le mot-clé implements et fournissent des corps concrets pour toutes les méthodes abstraites.

Exemple 1 : Interface Polygon

interface Polygon { void getArea(int length, int breadth); } class Rectangle implements Polygon { @Override public void getArea(int length, int breadth) { System.out.println("The area of the rectangle is " + (length * breadth)); } } class Main { public static void main(String[] args) { Rectangle r = new Rectangle(); r.getArea(5, 6); } }

Sortie :

The area of the rectangle is 30

Exemple 2 : Interface Language

interface Language { void getName(String name); } class ProgrammingLanguage implements Language { @Override public void getName(String name) { System.out.println("Programming Language: " + name); } } class Main { public static void main(String[] args) { ProgrammingLanguage lang = new ProgrammingLanguage(); lang.getName("Java"); } }

Sortie :

Programming Language: Java

Implémenter plusieurs interfaces

Une classe peut implémenter plusieurs interfaces :

interface A { /* membres */ } interface B { /* membres */ } class C implements A, B { /* implémentations */ }

Étendre une interface

Les interfaces peuvent étendre d'autres interfaces en utilisant extends :

interface Line { /* membres */ } interface Polygon extends Line { /* membres */ }

Une classe qui implémente Polygon doit fournir des méthodes pour les membres de Line et Polygon.

Étendre plusieurs interfaces

interface A { /* ... */ } interface B { /* ... */ } interface C extends A, B { /* ... */ }

Pourquoi utiliser les interfaces ?

• Abstraction : Définit des opérations sans dicter l'implémentation, permettant des comportements variés selon les classes.
• Spécification : Établit un contrat clair que les classes implémentantes doivent remplir.
• Héritage multiple : Permet à une classe d'adopter des comportements de plusieurs sources.
• Visibilité par défaut : Toutes les méthodes sont implicitement public ; les champs sont public static final.

Exemple de constantes implicites :

interface Language { String TYPE = "programming language"; // implicitement public static final void getName(); // implicitement public }

Méthodes par défaut (Java 8+)

Java 8 a introduit les méthodes default, permettant aux interfaces de contenir des corps de méthodes concrets :

default void getSides() { System.out.println("I can get sides of a polygon."); }

Les méthodes par défaut permettent la compatibilité ascendante lors de l'ajout de nouvelles méthodes aux interfaces sans casser les implémentations existantes.

Exemple : Utilisation de méthode par défaut

interface Polygon { void getArea(); default void getSides() { System.out.println("I can get sides of a polygon."); } } class Rectangle implements Polygon { @Override public void getArea() { int length = 6; int breadth = 5; int area = length * breadth; System.out.println("The area of the rectangle is " + area); } @Override public void getSides() { System.out.println("I have 4 sides."); } } class Square implements Polygon { @Override public void getArea() { int length = 5; int area = length * length; System.out.println("The area of the square is " + area); } } class Main { public static void main(String[] args) { Rectangle r = new Rectangle(); r.getArea(); r.getSides(); Square s = new Square(); s.getArea(); s.getSides(); } }

Sortie :

The area of the rectangle is 30 I have 4 sides. The area of the square is 25 I can get sides of a polygon.

Méthodes statiques et privées (Java 9+)

Les interfaces peuvent maintenant contenir des méthodes static, appelables via le nom de l'interface :

interface Polygon { static void helper() { /* ... */ } } Polygon.helper();

Les méthodes privées fournissent des utilitaires internes pour d'autres méthodes d'interface, assurant l'encapsulation.

Exemple pratique : Calculs de polygones

import java.lang.Math; interface Polygon { void getArea(); default void getPerimeter(int... sides) { int perimeter = 0; for (int side : sides) perimeter += side; System.out.println("Perimeter: " + perimeter); } } class Triangle implements Polygon { private final int a, b, c; private double area; Triangle(int a, int b, int c) { this.a = a; this.b = b; this.c = c; } @Override public void getArea() { double s = (a + b + c) / 2.0; area = Math.sqrt(s * (s - a) * (s - b) * (s - c)); System.out.println("Area: " + area); } } class Main { public static void main(String[] args) { Triangle t = new Triangle(2, 3, 4); t.getArea(); t.getPerimeter(2, 3, 4); } }

Sortie :

Area: 2.9047375096555625 Perimeter: 9

Dans cet exemple, l'interface Polygon fournit une méthode getPerimeter réutilisable, tandis que chaque forme implémente son propre calcul d'aire.