[POO] Appeler une fonction qui remonte dans les classes parentes

[sourivore]

Bonjour j'ai plusieurs classes qui suivent ce schéma :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class A{
  public function myFunc(){
    //Actions propres aux objets de la classe A
  }
}
class B extends A{
  public function myFunc(){
    //Actions propres aux objets de la classe B
  }
}
class C extends B{
  public function myFunc(){
    //Actions propres aux objets de la classe C
  }
}
$objet = new C();
$objet->myFunc();

Or si je crée un objet de class C et que j'appelle la méthode myFunc, seules les actions définies dans la méthode myFunc de la classe C sont appelées.
C'est à dire qu'il n'y a pas de remontée comme je le souhaiterais (myFunc de la classe C puis myFunc de la classe B et enfin myFunc de la classe A)

Y a t il un moyen d'effectuer ça intelligemment?

Il y a bien sûr une solution qui est la suivante mais que je ne trouve ni propre ni élégante ni futée :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class A{
  public function myFunc(){
    //Actions propres aux objets de la classe A
   ...
  }
}
class B extends A{
  public function myFuncB(){
    //Actions propres aux objets de la classe B
   ...
   $this->myFuncA();
  }
}
class C extends B{
  public function myFuncC(){
    //Actions propres aux objets de la classe B
   ...
   $this->myFuncB();
  }
}
$objet = new C();
$objet->myFuncC();

Edit : Petite précision pour ce qui connaissent il me semblent que c'est l'équivalent des classes virtuelles de .NET que je recherche

[Phelim]

Oui, il suffit d'employer le designe pattern decorator ou strategie.

Exemple d'implantation simple du decorator

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
//l interface est la pour faire plus propre (tu couples ton code par rapport à une interface et non par rapport à toutes les classes)
 
interface decorator{
  public function myFunc();
}
 
class A implements decorator{
  public $children;
  public __construct($children){
      $this -> children = $children
  }
  public function myFunc($a){
    //Actions propres aux objets de la classe A
    $a = 10 + $a;
    return $this -> $children -> myFunc($a);
  }
}
class B implements decorator{
  public $children;
  public __construct($children){
      $this -> children = $children
  }
  public function myFunc($a){
    //Actions propres aux objets de la classe B
    $a = 100 + $a;
    return $this -> $children -> myFunc($a);
  }
}
class C implements decorator{
  public $children;
  public __construct($children){
      $this -> children = $children
  }
  public function myFunc($a){
    //Actions propres aux objets de la classe C
    $a = 1000 + $a;
    return $this -> $children -> myFunc($a);
  }
 
}
class Initial {
  public function myFunc($a){
    //Actions propres aux objets de la classe A
    return $a;
  }
}
//utilisation
$objet = new C(new A(new Initial));
$objet->myFunc(5);// renvoie 1015
$objet = new B(new A(new Initial));
$objet->myFunc(5);// renvoie 115
$objet = new B(new B(new B(new Initial)));
$objet->myFunc(5);// renvoie 305
$objet = new C(new C(new A(new Initial)));
$objet->myFunc(5);// renvoie 2015

Voila une implémentation propre et ultramodulaire. Rien ne t'empeche de rajouter une class D qui va rajouter une multiplication par exemple

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class D implements decorator{
  public $children;
  public __construct($children){
      $this -> children = $children
  }
  public function myFunc($a){
    //Actions propres aux objets de la classe C
    $a = 5 * $a;
    return $this -> $children -> myFunc($a);
  }
 
}

Pour le pattern, strategie, c'est pareil sauf que l'on part de l'objet le plus bas pour remonter au plus haut.