PHP OOP - Héritage
PHP - Qu'est-ce que l'héritage ?
L'héritage en OOP correspond à la situation où une classe dérive d'une autre classe.
La classe enfant héritera de toutes les propriétés et méthodes publiques et protégées de la classe parente. De plus, elle peut avoir ses propres propriétés et méthodes.
Une classe héritée est définie en utilisant le mot-clé extends .
Regardons un exemple :
Exemple
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
public function intro() {
echo "Le fruit est {$this->name} et la couleur est {$this->color}.";
}
}
// La fraise hérite de Fruit
class Strawberry extends Fruit {
public function message() {
echo "Suis-je un fruit ou une baie ? ";
}
}
$strawberry = new Strawberry("Fraise", "rouge");
$strawberry->message();
$strawberry->intro();
?> Exemple expliqué
La classe Strawberry hérite de la classe Fruit.
Cela signifie que la classe Strawberry peut utiliser les propriétés publiques $name et $color ainsi que les méthodes publiques __construct() et intro() de la classe Fruit grâce à l'héritage.
La classe Strawberry a également sa propre méthode : message().
PHP - Héritage et le Modificateur d'Accès Protégé
Dans le chapitre précédent, nous avons appris que les propriétés ou méthodes protected peuvent être accessibles au sein de la classe et par les classes dérivées de cette classe. Qu'est-ce que cela signifie ?
Regardons un exemple :
Exemple
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
protected function intro() {
echo "Le fruit est {$this->name} et la couleur est {$this->color}.";
}
}
class Strawberry extends Fruit {
public function message() {
echo "Suis-je un fruit ou une baie ? ";
}
}
// Essayez d'appeler les trois méthodes depuis l'extérieur de la classe
$strawberry = new Strawberry("Fraise", "rouge"); // OK. __construct() est public
$strawberry->message(); // OK. message() est public
$strawberry->intro(); // ERREUR. intro() est protégé
?> Dans l'exemple ci-dessus, nous voyons que si nous essayons d'appeler une méthode protected (intro()) depuis l'extérieur de la classe, nous recevrons une erreur.
La méthode public fonctionnera très bien !
Regardons un autre exemple :
Exemple
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
protected function intro() {
echo "Le fruit est {$this->name} et la couleur est {$this->color}.";
}
}
class Strawberry extends Fruit {
public function message() {
echo "Suis-je un fruit ou une baie ? ";
// Appeler la méthode protégée depuis la classe dérivée - OK
$this -> intro();
}
}
$strawberry = new Strawberry("Fraise", "rouge"); // OK. __construct() est public
$strawberry->message(); // OK. message() est public et appelle intro() (qui est protégé) depuis la classe dérivée
?> Dans l'exemple ci-dessus, nous voyons que tout fonctionne bien ! C'est parce que nous appelons la méthode protected (intro()) depuis l'intérieur de la classe dérivée.
PHP - Surcharge des Méthodes Héritées
Les méthodes héritées peuvent être surchargées en redéfinissant les méthodes (en utilisant le même nom) dans la classe enfant.
Regardez l'exemple ci-dessous. Les méthodes __construct() et intro() dans la classe enfant (Strawberry) remplaceront les méthodes __construct() et intro() dans la classe parente (Fruit) :
Exemple
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
public function intro() {
echo "Le fruit est {$this->name} et la couleur est {$this->color}.";
}
}
class Strawberry extends Fruit {
public $weight;
public function __construct($name, $color, $weight) {
$this->name = $name;
$this->color = $color;
$this->weight = $weight;
}
public function intro() {
echo "Le fruit est {$this->name}, la couleur est {$this->color}, et le poids est {$this->weight} grammes.";
}
}
$strawberry = new Strawberry("Fraise", "rouge", 50);
$strawberry->intro();
?> PHP - Le mot-clé final
Le mot-clé final peut être utilisé pour empêcher l'héritage de classe ou pour empêcher la surcharge de méthode.
L'exemple suivant montre comment empêcher l'héritage de classe :
Exemple
<?php
final class Fruit {
// un peu de code
}
// entraînera une erreur
class Strawberry extends Fruit {
// un peu de code
}
?> L'exemple suivant montre comment empêcher la surcharge de méthode :
Exemple
<?php
class Fruit {
final public function intro() {
// un peu de code
}
}
class Strawberry extends Fruit {
// entraînera une erreur
public function intro() {
// un peu de code
}
}
?>