PHP - Moștenire
Prin moștenire, o clasă copil primește toate proprietățile și metodele publice și protejate ale clasei părinte și poate adăuga propriile proprietăți și metode.
Notă: O clasă copil nu are acces la metodele private ale părintelui ei.
Folosește cuvântul cheie extends pentru a crea o clasă moștenită.
În exemplul următor, Strawberry extinde Fruit. Datorită moștenirii, poate folosi proprietățile publice $name și $color și metodele publice __construct() și intro() din Fruit. Pe lângă acestea, Strawberry definește încă o metodă proprie, message().
Exemplu
Strawberry primește tot ce este public din Fruit și adaugă message():
Ieșire: script PHP
<?php
// Clasa părinte
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
public function intro() {
echo "Fructul este $this->name și culoarea este $this->color.<br>";
}
}
// Strawberry moștenește de la Fruit
class Strawberry extends Fruit {
public function message() {
echo "Sunt fruct sau boabă? ";
}
}
$strawberry = new Strawberry("Strawberry", "red");
$strawberry->intro();
$strawberry->message();
?>
PHP - Moștenirea și modificatorul de acces protected
Capitolul anterior a arătat că membrii protected sunt accesibili clasei însăși și claselor derivate din ea.
Pentru codul din exterior lucrurile stau altfel: un apel la o metodă protected de acolo se termină cu o eroare, în timp ce metodele public continuă să funcționeze normal.
Exemplu
Aici, codul din exterior apelează metoda protected intro() și primește o eroare:
Ieșire: script PHP
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
protected function intro() {
echo "Fructul este $this->name și culoarea este $this->color.";
}
}
class Strawberry extends Fruit {
public function message() {
echo "Sunt fruct sau boabă? ";
}
}
// Încercăm să apelăm toate cele trei metode din afara clasei
$strawberry = new Strawberry("Strawberry", "red"); // OK. __construct() este public
$strawberry->message(); // OK. message() este public
$strawberry->intro(); // EROARE. intro() este protected
?>
Exemplu
Clasa derivată poate apela aceeași metodă protected din interior, fără nicio problemă:
Ieșire: script PHP
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
protected function intro() {
echo "Fructul este $this->name și culoarea este $this->color.";
}
}
class Strawberry extends Fruit {
public function message() {
echo "Sunt fruct sau boabă? ";
// Apelăm metoda protected din interiorul clasei derivate - OK
$this -> intro();
}
}
$strawberry = new Strawberry("Strawberry", "red"); // OK. __construct() este public
$strawberry->message(); // OK. message() este public și apelează intro() (care este protected) din interiorul clasei derivate
?>
PHP - Suprascrierea metodelor moștenite
O clasă copil poate înlocui o metodă pe care o moștenește. Este suficient să definești în clasa copil o metodă cu același nume; aceasta se numește suprascriere.
În exemplul următor, Strawberry (copilul) oferă propriile __construct() și intro(), iar acestea suprascriu versiunile din Fruit (părintele):
Exemplu
Versiunile lui __construct() și intro() din Strawberry sunt cele care rulează:
Ieșire: script PHP
<?php
class Fruit {
public $name;
public $color;
public function __construct($name, $color) {
$this->name = $name;
$this->color = $color;
}
public function intro() {
echo "Fructul este $this->name și culoarea este $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 "Un $this->name este $this->color, iar greutatea este $this->weight grame.";
}
}
$strawberry = new Strawberry("Strawberry", "red", 50);
$strawberry->intro();
?>
PHP - Cuvântul cheie final
Uneori, o clasă sau o metodă trebuie să rămână exact așa cum a fost scrisă. Cuvântul cheie final face exact asta: pe o clasă blochează moștenirea, iar pe o metodă blochează suprascrierea.
Exemplu
O clasă marcată cu final nu poate fi extinsă, așa că acest cod se termină cu o eroare fatală:
Ieșire: script PHP
<?php
final class Fruit {
// niște cod
}
// va produce o eroare
class Strawberry extends Fruit {
// niște cod
}
?>
Exemplu
O metodă marcată cu final nu poate fi suprascrisă într-o clasă copil, așa că și acest cod se termină cu o eroare fatală:
Ieșire: script PHP
<?php
class Fruit {
final public function intro() {
// niște cod
}
}
class Strawberry extends Fruit {
// va produce o eroare
public function intro() {
// niște cod
}
}
?>