Héritage multiple. Question d'architecture.
Bonjour tout le monde,
J'ai une petite question plutôt d'ordre architecture que code pure.
Je vous explique mon dilemme. J'ai une classe de base - appelé originalement Base - dont j'ai fais dériver 2 classes - SubBase1 et SubBase2. Chacune de ces deux classes re-implémente une méthode appelé lock(). Jusque la rien d'affolant.
J'ai ensuite eu besoin de spécialiser chacune de ces 2 méthodes lock() de la même façon.
Ma première façon de faire a été de dériver chacune de mes 2 classe - SubBase1Spé et SubBase2Spé - et de redéfinir les 2 implémentations de lock(), sachant que chacune d'elle appelle la version de leur classe de base.
La encore rien de bien méchant.
Après implémentation de ces 2 nouvelles classes dérivées, je me suis rendu compte que le code de spécialisation était complètement dupliqué entre mes deux classes. Et pour éviter cette duplication de code j'ai donc créé une classe de spécialisation - appelé la encore très originalement Spe - dont j'ai fait hérité chacune de mes 2 classes SubBase1Spé et SubBase2Spé.
Normalement la, vous êtes perdu, alors voila un petit diagramme de classe:
Code:
1
2
3
4
5
6
7
8
9
10
11
|
Base
|
+------+-------+
| |
SubBase1 SubBase2
| |
| Spé |
| +----+-----+ |
| | | |
SubBase1Spé SubBase2Spé |
Et en code:
Code:
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
30
31
32
33
34
35
36
37
38
|
class Base(object):
''' Classe de base '''
def lock(self):
print "Base::lock() method call."
raise NotImplemented()
class SubBase1(Base):
''' Classes derivee 1 '''
def lock(self):
print "SubBase1::lock() method call."
class SubBase2(Base):
''' Classes derivee 2 '''
def lock(self):
print "SubBase2::lock() method call."
class Spe(object):
''' Classe de specialisation '''
def lock(self):
print "Spe::lock() method call."
return super(Spe, self).lock()
class SubBase1Spe(Spe, SubBase1):
''' Classe specialisee 1 '''
class SubBase2Spe(Spe, SubBase2):
''' Classe specialisee 1 '''
print "Creation de SubBase1Spe"
SubBase1Spe().lock()
print
print "Creation de SubBase2Spe"
SubBase2Spe().lock()
print |
Et voila, ca marche. Mais en relisant mon code, je me rend compte que la méthode lock() de Spe se retrouve à appeler une méthode d'une classe au même niveau qu'elle dans la hiérarchie... et ca c'est.... moche, en étant particulièrement gentil avec moi-même :-)
ex: Spe::lock() appelle SubBase1::lock() ou SubBase2::lock().
Je ne sais pas trop comment faire quelque chose d'élégant avec ca. Je suis en train de me dire que le code dupliqué avait au moins la bonne idée d'être une bonne approche de l'héritage de tout cela. Quelqu'un aurait-il une idée sur une bonne façon de faire les choses ?
Merci d'avance.
