PHP - Clase și metode abstracte
Unele metode au sens doar după ce o clasă copil completează detaliile. O metodă abstractă este exact așa ceva: părintele o declară, dar nu îi oferă nicio implementare și lasă această muncă în seama clasei sau a claselor copil.
O clasă cu cel puțin o metodă abstractă se numește clasă abstractă. Scopul ei este să impună o regulă: fiecare clasă derivată (clasă copil) trebuie să implementeze metodele abstracte declarate de părinte.
Atât clasele abstracte, cât și metodele abstracte sunt marcate cu cuvântul cheie abstract.
Iată cum arată asta în practică:
Exemplu
Car este abstractă și declară o metodă abstractă intro(), pe care fiecare dintre cele două clase copil o implementează:
Ieșire: script PHP
<?php
// Clasă de bază abstractă
abstract class Car {
public $name;
// Metodă neabstractă
public function __construct($name) {
$this->name = $name;
}
// Metodă abstractă - obligă clasele copil să o implementeze
abstract public function intro();
}
// Clasă copil care extinde clasa abstractă
class Audi extends Car {
public function intro() {
return "Calitate germană! Sunt un $this->name!";
}
}
// Clasă copil care extinde clasa abstractă
class Citroen extends Car {
public function intro() {
return "Extravaganță franceză! Sunt un $this->name!";
}
}
// Creăm obiecte ale claselor copil
$audi = new audi("Audi");
echo $audi->intro();
echo "<br>";
$citroen = new citroen("Citroen");
echo $citroen->intro();
?>
Explicația exemplului
Audi și Citroen extind amândouă clasa abstractă Car. Datorită acestei moșteniri, pot folosi proprietatea ei publică $name și metoda ei publică __construct().
intro() este diferită. Este abstractă, așa că fiecare clasă copil trebuie să ofere propria implementare.
Observații despre clasele abstracte
O clasă copil trebuie să respecte câteva reguli când implementează o metodă abstractă. Metoda trebuie să păstreze același nume, iar modificatorul ei de acces trebuie să fie același sau mai puțin restrictiv. De exemplu, o metodă abstractă declarată protected poate rămâne protected sau poate deveni public în clasa copil, dar nu poate deveni niciodată private. Tipul și numărul argumentelor obligatorii trebuie, de asemenea, să coincidă, deși clasa copil poate adăuga liber argumente opționale.
Pe scurt, aceste reguli se aplică atunci când o clasă copil moștenește o clasă abstractă:
- Metoda din clasa copil are același nume ca metoda abstractă și o redeclară
- Modificatorul ei de acces este același ca al părintelui sau mai puțin restrictiv
- Primește același număr de argumente obligatorii și poate adăuga argumente opționale
PHP - Metodă abstractă cu argument
Și metodele abstracte pot primi argumente. Următoarele două exemple arată cum funcționează asta:
Exemplu
Metoda abstractă declară un argument, $name, iar clasa copil o implementează cu același argument:
Ieșire: script PHP
<?php
abstract class ParentClass {
// Metodă abstractă cu un argument
abstract protected function prefixName($name);
}
class ChildClass extends ParentClass {
public function prefixName($name) {
if ($name == "John Doe") {
$prefix = "Dl.";
} elseif ($name == "Jane Doe") {
$prefix = "Dna.";
} else {
$prefix = "";
}
return "$prefix $name";
}
}
$class = new ChildClass;
echo $class->prefixName("John Doe");
echo "<br>";
echo $class->prefixName("Jane Doe");
echo "<br>";
echo $class->prefixName("Baby Doe");
?>
Exemplu
Aici, clasa copil adaugă două argumente opționale pe care metoda abstractă a părintelui nu le declară:
Ieșire: script PHP
<?php
abstract class ParentClass {
// Metodă abstractă cu un argument
abstract protected function prefixName($name);
}
class ChildClass extends ParentClass {
// Clasa copil poate defini argumente opționale care nu există în metoda abstractă a clasei părinte
public function prefixName($name, $separator = ".", $greet = "Dragă") {
if ($name == "John Doe") {
$prefix = "Dl";
} elseif ($name == "Jane Doe") {
$prefix = "Dna";
} else {
$prefix = "";
}
return "$greet $prefix$separator $name";
}
}
$class = new ChildClass;
echo $class->prefixName("John Doe");
echo "<br>";
echo $class->prefixName("Jane Doe");
?>