Comment peut-on implémenter l'héritage multiple en Java?

L'héritage multiple d'implémentation de classes en Java n'est pas directement supporté en raison du "problème du diamant". Cependant, sa fonctionnalité peut être atteinte par les moyens suivants :

1. Interfaces : La classe peut implémenter plusieurs interfaces. Les interfaces définissent uniquement les signatures des méthodes, pas leur implémentation.

   interface InterfaceA {
       void methodA();
   }
   
   interface InterfaceB {
       void methodB();
   }
   
   class MyClass implements InterfaceA, InterfaceB {
       @Override
       public void methodA() {
           // Implémentation de methodA
       }
   
       @Override
       public void methodB() {
           // Implémentation de methodB
       }
   }
   

   Avec l'apparition des méthodes par défaut en Java 8, les interfaces peuvent également fournir des implémentations par défaut.

   interface InterfaceC {
       default void defaultMethod() {
           System.out.println("Implémentation par défaut");
       }
   }
   
   class MyClass2 implements InterfaceC {
       // Peut utiliser defaultMethod ou le redéfinir
   }
   

2. Composition : Au lieu d'hériter de plusieurs classes, une classe peut contenir des instances d'autres classes (membres).

   class ComponentA {
       void methodA() {
           // Implémentation de methodA
       }
   }
   
   class ComponentB {
       void methodB() {
           // Implémentation de methodB
       }
   }
   
   class MyClass3 {
       private ComponentA compA = new ComponentA();
       private ComponentB compB = new ComponentB();
   
       public void delegateMethodA() {
           compA.methodA();
       }
   
       public void delegateMethodB() {
           compB.methodB();
       }
   }
   

   La classe MyClass3 délègue les appels de méthodes aux objets compA et compB.

Comparaison :

Mécanisme	Héritage d'implémentation	Problème du diamant	Flexibilité
Interfaces	Non (jusqu'à default)	Non	Élevée
Composition	Oui	Non	Élevée