Discussion :

[loustalet]

Bonjour,

Quelle différence entre l'appel à un membre protégé de la classe mère par l'intermédiaire de parent ou this. Le code suivant fournit le même résultat dans la fonction uneFonction() ?
Que vaut-il mieux faire ?

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
 
<?php
 
class mere {
 
    protected function MereProtegee() {
        return "bonjour";
    }
}
 
class fille extends mere {
 
    public function uneFonction() {
        echo $this->MereProtegee();
		echo parent::MereProtegee();
    }
}
 
$unObjet = new fille();
$unObjet->uneFonction();
?>

merci pour les explications

[vg33]

Tu utilises parent si tu redéfinis une méthode dans la classe fille mais que tu veux quand même appeler la même méthode de la classe mère.
Exemple :

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
class mere {
 
    protected function uneFonction() {
        return "bonjour";
    }
}
 
class fille extends mere {
 
    public function uneFonction() {
        // plein de choses intéressantes
 
        // puis :
        return parent::uneFonction();
    }
}
 
$unObjet = new fille();
$unObjet->uneFonction();

[Exia_]

Bonjour,

essaye ce code :

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
<?php
 
	class mere{
		public function maFonction(){
			echo "ma fonction mere<br /> ";
		}
	}
 
	class fille extends mere{
 
		public function maFonction(){
			echo "ma fonction fille<br />";
		}
 
		public function uneFonction(){
			$this->maFonction();
 
			parent::maFonction();
		}
	}
 
	$uneFille = new fille();
	$uneFille->uneFonction();
?>

Si tu utilise parent:: la fonction de la classe parent sera appelée,
si tu utilise $this c'est la fonction de la classe fille qui sera appelée.

Dans ton exemple $this et parent:: appellent la même fonction car tu n'à qu'une seul fonction qui s'appelle maFonction(), alors que dans mon exemple j'en ai deux, une qui appartient à la classe mère et une qui appartient à la classe fille donc tu aura deux comportement :
-L'appel de la fonction maFonction() de la classe mère en utilisant parent:: affichera "ma fonction mère"
-L'appel de la fonction maFonction() de la classe fille an utilisant $this-> affichera "ma fonction fille"

Ce qui te permet en prenant l'exemple d'une classe personnage, une classe guerrier héritant de personnage et une classe magicien héritant de personnage lui aussi, de ne pas avoir à utiliser des fonctions qui iront récupérer les attributs de la classe mère pour avoir à les afficher ( ou plus simple de passer les attributs des classe mère en protected au lieu de private ce qui permet de pouvoir les manipuler librement à l'intérieur des classes filles tout en les protégeant de l'extérieur ).

Une petit exemple sera plus parlant

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
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
57
58
<?php
 
	class Personnage{
		private $nom;
 
		public function __construct($nomP){
			$this->nom = $nomP;
		}
 
		public function afficher(){
			echo '<br />Le nom : ' . $this->nom;
		}
	}
 
	class Guerrier extends Personnage{
		private $nomArme;
 
		public function __construct($nomPerso, $nomArme){
			parent::__construct($nomPerso);
			$this->nomArme = $nomArme;
		}
 
		public function afficher(){
			echo '<br />Guerrier :';
			parent::afficher();
			echo '<br />L\'arme : ' . $this->nomArme;
		}
	}
 
	class Magicien extends Personnage{
		private $magie;
 
		public function __construct($nomP, $nomMagie){
			parent::__construct($nomP);
			$this->magie = $nomMagie;
		}
 
		public function afficher(){
			echo '<br />Mago :';
			parent::afficher();
			echo '<br />La magie : ' . $this->magie;
		}
	}
 
	$monPerso = new Personnage("Perso");
	$monGuerrier = new Guerrier("Guerrier", "Grosse hache");
	$monMago = new Magicien("Mago", "Feu");
 
	$monPerso->afficher();
 
	echo '<br />';
 
	$monGuerrier->afficher();
 
	echo '<br />';
 
	$monMago->afficher();
?>

essaye le code, tu t’apercevra que la fonction afficher des classes filles appellent la fonction afficher de la classe mère pour afficher leurs nom puis va afficher sont arme pour le guerrier ou le sa magie pour le magicien.

PS : Pour ton exemple passe ta fonction en private et tu ne pourra plus l'appeler même au sein d'une classe fille, alors que pour les fonctions déclarées en protected tu pourra les appeler dans une classe fille.

[loustalet]

Merci pour vos explications bien argumentées.
Effectivement dans ce cas là c'est clair !

OK aussi pour protected.
Je reviens à mon cas particulier où le membre n'est pas dans la classe fille, mais seulement de la classe mère, je suppose que tu préconises un appel par parent plutôt que par $this.
C'est ce que je préconise, ça me parait toujours plus clair !!!
Bonne journée

[gene69]

non !
quand la méthode n'est pas surchargée il vaut mieux appeler avec $this-> que parent::.

D'abord parce que par une étrangeté du langage Paamayim Nekudotayim est souvent associé à "static" sauf dans ce cas express. Donc c'est trompeur.

Ensuite parce que tant que tu n'as qu'un seul niveau de dérivation tu maitrises bien ce qu'il se passe et tu peux être tenté de faire ce genre de raccourci qui montre que tu n'as pas confiance dans l'héritage...
Le comportement "objet" usuel en POO est de dire que la définition courante de la méthode ($this->) est la bonne même si obtenue par héritage. Si tu appelles parent:: c'est que tu as une bonne raison de le faire (dont tu l'as surchargé - ou tu es en train de la surcharger et la méthode de la classe fille est devenue brutalement incompatible avec la méthode de la classe mère ), c'est tout.

Ne cherche pas à simplifier le travail du compilateur, on ne sait jamais comment il est optimisé ... et comment sera utilisé ton code par la suite.