Le classi astratte sono classi che contengono uno o più metodi astratti. Un metodo astratto è un metodo dichiarato, ma non contiene alcuna implementazione. Le classi astratte non possono essere istanziate e richiedono sottoclassi per fornire implementazioni per i metodi astratti.
1. Impossibile istanziare la classe astratta : le classi definite come astratte non possono essere istanziate e anche qualsiasi classe che contiene almeno un metodo astratto deve essere astratta.
Esempio sotto:
abstract class AbstractClass
{
abstract protected function getValue();
abstract protected function prefixValue($prefix);
public function printOut() {
echo "Hello how are you?";
}
}
$obj=new AbstractClass();
$obj->printOut();
//Fatal error: Cannot instantiate abstract class AbstractClass
2. Qualsiasi classe che contiene almeno un metodo astratto deve essere anche astratta : la classe astratta può avere metodi astratti e non astratti, ma deve contenere almeno un metodo astratto. Se una classe ha almeno un metodo astratto, la classe deve essere dichiarata astratta.
Nota: i tratti supportano l'uso di metodi astratti per imporre requisiti alla classe partecipante.
Esempio sotto:
class Non_Abstract_Class
{
abstract protected function getValue();
public function printOut() {
echo "Hello how are you?";
}
}
$obj=new Non_Abstract_Class();
$obj->printOut();
//Fatal error: Class Non_Abstract_Class contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Non_Abstract_Class::getValue)
3. Un metodo astratto non può contenere body : i metodi definiti come astratti dichiarano semplicemente la firma del metodo - non possono definire l'implementazione. Ma un metodo non astratto può definire l'implementazione.
abstract class AbstractClass
{
abstract protected function getValue(){
return "Hello how are you?";
}
public function printOut() {
echo $this->getValue() . "\n";
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";
//Fatal error: Abstract function AbstractClass::getValue() cannot contain body
4. Quando si eredita da una classe astratta, tutti i metodi contrassegnati come astratti nella dichiarazione della classe del genitore devono essere definiti dal figlio : se si eredita una classe astratta, è necessario fornire le implementazioni a tutti i metodi astratti in essa contenuti.
abstract class AbstractClass
{
// Force Extending class to define this method
abstract protected function getValue();
// Common method
public function printOut() {
print $this->getValue() . "<br/>";
}
}
class ConcreteClass1 extends AbstractClass
{
public function printOut() {
echo "dhairya";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
//Fatal error: Class ConcreteClass1 contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (AbstractClass::getValue)
5. Stessa (o meno limitata) visibilità : quando si eredita da una classe astratta, tutti i metodi contrassegnati come astratti nella dichiarazione della classe del genitore devono essere definiti dal figlio; inoltre, questi metodi devono essere definiti con la stessa (o con una visibilità meno limitata). Ad esempio, se il metodo astratto è definito come protetto, l'implementazione della funzione deve essere definita come protetta o pubblica, ma non privata.
Nota che il metodo astratto non dovrebbe essere privato.
abstract class AbstractClass
{
abstract public function getValue();
abstract protected function prefixValue($prefix);
public function printOut() {
print $this->getValue();
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."<br/>";
//Fatal error: Access level to ConcreteClass1::getValue() must be public (as in class AbstractClass)
6. Le firme dei metodi astratti devono corrispondere : Quando si eredita da una classe astratta, tutti i metodi contrassegnati come astratti nella dichiarazione della classe del genitore devono essere definiti dal figlio; le firme dei metodi devono corrispondere, cioè i suggerimenti sul tipo e il numero di gli argomenti devono essere gli stessi. Ad esempio, se la classe figlia definisce un argomento opzionale, mentre la firma del metodo astratto non lo fa, non vi è conflitto nella firma.
abstract class AbstractClass
{
abstract protected function prefixName($name);
}
class ConcreteClass extends AbstractClass
{
public function prefixName($name, $separator = ".") {
if ($name == "Pacman") {
$prefix = "Mr";
} elseif ($name == "Pacwoman") {
$prefix = "Mrs";
} else {
$prefix = "";
}
return "{$prefix}{$separator} {$name}";
}
}
$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "<br/>";
echo $class->prefixName("Pacwoman"), "<br/>";
//output: Mr. Pacman
// Mrs. Pacwoman
7. La classe astratta non supporta l'ereditarietà multipla : la classe astratta può estendere un'altra classe astratta, la classe astratta può fornire l'implementazione dell'interfaccia. Ma non supporta l'ereditarietà multipla.
interface MyInterface{
public function foo();
public function bar();
}
abstract class MyAbstract1{
abstract public function baz();
}
abstract class MyAbstract2 extends MyAbstract1 implements MyInterface{
public function foo(){ echo "foo"; }
public function bar(){ echo "bar"; }
public function baz(){ echo "baz"; }
}
class MyClass extends MyAbstract2{
}
$obj=new MyClass;
$obj->foo();
$obj->bar();
$obj->baz();
//output: foobarbaz
Nota: si prega di notare che l'ordine o il posizionamento delle classi nel codice possono influenzare l'interprete e possono causare un errore irreversibile. Quindi, quando si utilizzano più livelli di astrazione, fare attenzione al posizionamento delle classi all'interno del codice sorgente.
l'esempio seguente causerà un errore irreversibile: Classe "cavallo" non trovata
class cart extends horse {
public function get_breed() { return "Wood"; }
}
abstract class horse extends animal {
public function get_breed() { return "Jersey"; }
}
abstract class animal {
public abstract function get_breed();
}
$cart = new cart();
print($cart->get_breed());