PHP OOP - Héritage
PHP - Qu'est-ce que l'héritage ?
Héritage en POO = Lorsqu'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 parent. De plus, il peut avoir ses propres propriétés et méthodes.
Une classe héritée est définie à l'aide du mot- extends
clé.
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 "The fruit is {$this->name}
and the color is {$this->color}.";
}
}
// Strawberry is inherited from Fruit
class
Strawberry extends Fruit {
public
function message() {
echo "Am I a fruit or a
berry? ";
}
}
$strawberry = new Strawberry("Strawberry", "red");
$strawberry->message();
$strawberry->intro();
?>
Exemple expliqué
La classe Strawberry est héritée 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 en raison de l'héritage.
La classe Strawberry possède également sa propre méthode : message().
PHP - Héritage et modificateur d'accès protégé
Dans le chapitre précédent, nous avons appris que les protectedpropriétés ou les méthodes sont accessibles au sein de la classe et par les classes dérivées de cette classe. Qu'est-ce que ça veut dire?
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 "The fruit is {$this->name}
and the color is {$this->color}.";
}
}
class
Strawberry extends Fruit {
public
function message() {
echo "Am I a fruit or a
berry? ";
}
}
// Try to call all three methods from outside class
$strawberry = new Strawberry("Strawberry", "red");
// OK. __construct() is public
$strawberry->message(); // OK. message()
is public
$strawberry->intro(); // ERROR. intro()
is protected
?>
Dans l'exemple ci-dessus, nous voyons que si nous essayons d'appeler une protected
méthode (intro()) depuis l'extérieur de la classe, nous recevrons une erreur. public
les méthodes fonctionneront bien!
Prenons 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 "The
fruit is {$this->name} and the color is {$this->color}.";
}
}
class Strawberry extends Fruit {
public function message() {
echo "Am I a fruit or a berry? ";
// Call protected
method from within derived class - OK
$this ->
intro();
}
}
$strawberry = new Strawberry("Strawberry", "red"); // OK. __construct() is
public
$strawberry->message(); // OK. message() is
public and it calls intro() (which is protected) from within the
derived class
?>
Dans l'exemple ci-dessus, nous voyons que tout fonctionne bien ! C'est parce que nous appelons la
protected
méthode (intro()) depuis l'intérieur de la classe dérivée.
PHP - Remplacement des méthodes héritées
Les méthodes héritées peuvent être remplacées en redéfinissant les méthodes (utilisez le même nom) dans la classe enfant.
Regardez l'exemple ci-dessous. Les méthodes __construct() et intro() de la classe enfant (Strawberry) remplaceront les méthodes __construct() et intro() de la classe parent (Fruit) :
Exemple
<?php
class Fruit {
public
$name;
public $color;
public
function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
public function intro() {
echo "The fruit is {$this->name}
and the color is {$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 "The fruit is {$this->name}, the color is {$this->color},
and the weight is {$this->weight} gram.";
}
}
$strawberry = new Strawberry("Strawberry", "red",
50);
$strawberry->intro();
?>
PHP - Le dernier mot-clé
Le final
mot-clé peut être utilisé pour empêcher l'héritage de classe ou pour empêcher le remplacement de méthode.
L'exemple suivant montre comment empêcher l'héritage de classe :
Exemple
<?php
final class Fruit {
// some code
}
//
will result in error
class
Strawberry extends Fruit {
// some code
}
?>
L'exemple suivant montre comment empêcher le remplacement de méthode :
Exemple
<?php
class Fruit {
final public function intro() {
// some code
}
}
class
Strawberry extends Fruit {
//
will result in error
public function intro() {
// some code
}
}
?>