Discussion :

[longbeach]

L'heritage multiple en Java n'est pas permis.
Une classe ne peut hériter de plus d'une classe.
Mais supposons qu'on ait le diagramme de classes suivant :

Z
/\
X Y
\/
A

Les classes X et Y héritent de la classe Z, et la classe A hérite des classes X et Y.

Quelles solutions / contournements sont possibles pour implémenter cet héritage multiple en Java ?

[adiGuba]

Salut,

Quelles solutions / contournements sont possibles pour implémenter cet héritage multiple en Java ?

Aucun : c'est justement pour éviter ce genre de cas que l'héritage multiple est interdit...

a++

[DevTeam_]

Tu peux déclarer X et Y comme étant des interfaces qu'implémente A, mais j'imagine que ça suppose qu' X et Y n'aient aucun code dans les méthodes implémentées...

EDIT : non, chui naze, pour que ça marche il faudrait que Z soit elle-aussi une interface...

[dingoth]

Pour faire de l'héritage multiple, aucune solution.

Par contre, dans le monde java, il est possible de faire "comme si" avec la composition et l'héritage mélangés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public interface Z {
  void z ();
}
 
public interface X extends Z {
  void x ();
}
 
public interface Y extends Z {
  void y ();
}
 
public class ClasseZ implements Z {
  public void z () { ... }
}
 
public class ClasseX extends ClasseZ implements X {
  public void x () { ... }
}
 
public class ClasseY extends ClasseZ implements Y {
  public void y () { ... }
}
 
public class ClasseA extends ClasseX implements Y {
  private Y yImpl;
  public ClasseA () { yImpl = new ClasseY(); }
  public void y () { yImpl.y(); }
}

C'est très lourd, ce n'est pas pareil que de l'héritage multiple, mais c'est ce qui s'en rapproche le plus en java.

[spypunk]

De toute manière, il vaut mieux préférer une composition à un héritage dès que c'est possible (et cohérent avec le contexte).

[longbeach]

et que pensez-vous de cette approche ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
interface Z {
      void met();
}
 
class X implements Z {
   public  void met() { }
}
 
class Y implements Z {
   public  void met() { }
}
 
 
class A {
Z z;
X x = new X(); 
Y y = new Y(); 
z = x;
z.met(); 
z = y;
z.met();
}

[adiGuba]

C'est très lourd, ce n'est pas pareil que de l'héritage multiple, mais c'est ce qui s'en rapproche le plus en java.

La question est plutôt : pourquoi faire de l'héritage multiple ???

Il vaut mieux revoir la conception que de s'aventurer dans une architecture un peu tordu...

et que pensez-vous de cette approche ?

C'est à dire ? Que veux-tu mettre en évidence ?


a++