Implémenter plusieurs interfaces en Java
Ce didacticiel présente comment une classe peut implémenter plusieurs interfaces en Java et répertorie également quelques exemples de codes pour comprendre le sujet.
En Java, une interface est similaire à une classe sauf qu’elle ne peut avoir que des méthodes abstraites. Une interface est connue comme un modèle pour une classe, et la classe qui implémente une interface doit fournir une implémentation pour toutes les méthodes abstraites ou déclarer l’abstrait lui-même.
En Java, la classe ne peut étendre qu’une seule classe mais peut implémenter plusieurs interfaces. Donc, si quelqu’un vous le demande, une classe peut-elle implémenter plusieurs interfaces ? Ensuite, dites OUI.
Commençons par quelques exemples de code pour comprendre le concept. Il s’agit d’une structure générale d’implémentation d’interfaces multiples.
class A implements B, C, D
....Z
Les classes existantes dans les collections Java qui implémentent plusieurs interfaces sont :
En dehors du code du développeur, si nous remarquons la source JDK, nous constaterons que Java a utilisé plusieurs implémentations d’interface telles que ArrayList, la classe HashMap, etc.
ArrayList<E> implémente plusieurs interfaces
public class ArrayList<E>
extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
// Implements multiple interfaces
HashMap<K,V> implémente plusieurs interfaces
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable
// Implements multiple interfaces
Implémente plusieurs interfaces en Java
Java permet à une classe d’implémenter plusieurs interfaces. Ainsi, nous pouvons mettre en œuvre autant que nous voulons. Dans cet exemple, nous avons créé 3 interfaces puis les avons implémentées en utilisant une classe.
Lorsque vous travaillez avec l’interface, assurez-vous que la classe implémente toutes ses méthodes abstraites. Voir l’exemple ci-dessous où nous avons implémenté toutes les méthodes des 3 interfaces.
package javaexample;
interface A {
void showA();
}
interface B {
void showB();
}
interface C {
void showC();
}
public class SimpleTesting implements A, B, C {
public static void main(String[] args) {
SimpleTesting st = new SimpleTesting();
st.showA();
st.showB();
st.showC();
}
@Override
public void showA() {
System.out.println("Interface A");
}
@Override
public void showB() {
System.out.println("Interface B");
}
@Override
public void showC() {
System.out.println("Interface C");
}
}
Production:
Interface A
Interface B
Interface C
L’interface étend l’interface multiple en Java
Une interface peut également implémenter (étendre) plusieurs interfaces. Java permet de s’interfacer comme une classe et peut implémenter plusieurs interfaces.
Dans le cas de l’interface, nous devrions utiliser le mot-clé externds à la place de implements pour implémenter les interfaces. Voir l’exemple ci-dessous.
package javaexample;
interface A {
void showA();
}
interface B {
void showB();
}
interface C {
void showC();
}
interface D extends A, B, C {
void showD();
}
public class SimpleTesting implements D {
public static void main(String[] args) {
SimpleTesting st = new SimpleTesting();
st.showA();
st.showB();
st.showC();
st.showD();
}
@Override
public void showA() {
System.out.println("Interface A");
}
@Override
public void showB() {
System.out.println("Interface B");
}
@Override
public void showC() {
System.out.println("Interface C");
}
@Override
public void showD() {
System.out.println("Interface D");
}
}
Production:
Interface A
Interface B
Interface C
Interface D
Il est important que si vous implémentez une interface dans une classe, vous devez alors fournir des implémentations de méthodes abstraites, sinon le compilateur Java générera une erreur. Voir l’exemple ci-dessous.
package javaexample;
interface A {
void showA();
}
interface B {
void showB();
}
public class SimpleTesting implements A, B {
public static void main(String[] args) {
SimpleTesting st = new SimpleTesting();
st.showA();
st.showB();
}
@Override
public void showA() {
System.out.println("Interface A");
}
}
Production:
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The type SimpleTesting must implement the inherited abstract method B.showB()