Abstrakte Klassen sind Klassen, die eine oder mehrere abstrakte Methoden enthalten. Eine abstrakte Methode ist eine Methode, die deklariert ist, aber keine Implementierung enthält. Abstrakte Klassen können möglicherweise nicht instanziiert werden und erfordern Unterklassen, um Implementierungen für die abstrakten Methoden bereitzustellen.
1. Abstrakte Klasse kann nicht instanziiert werden : Klassen, die als abstrakt definiert sind, dürfen nicht instanziiert werden, und jede Klasse, die mindestens eine abstrakte Methode enthält, muss ebenfalls abstrakt sein.
Beispiel unten:
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. Jede Klasse, die mindestens eine abstrakte Methode enthält, muss ebenfalls abstrakt sein : Die abstrakte Klasse kann abstrakte und nicht abstrakte Methoden enthalten, muss jedoch mindestens eine abstrakte Methode enthalten. Wenn eine Klasse mindestens eine abstrakte Methode hat, muss die Klasse als abstrakt deklariert werden.
Hinweis: Merkmale unterstützen die Verwendung abstrakter Methoden, um Anforderungen an die ausstellende Klasse zu stellen.
Beispiel unten:
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. Eine abstrakte Methode darf keinen Body enthalten : Als abstrakt definierte Methoden deklarieren einfach die Signatur der Methode - sie können die Implementierung nicht definieren. Eine nicht abstrakte Methode kann jedoch die Implementierung definieren.
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. Beim Erben von einer abstrakten Klasse müssen alle in der Klassendeklaration des übergeordneten Elements als abstrakt gekennzeichneten Methoden vom Kind definiert werden : Wenn Sie eine abstrakte Klasse erben, müssen Sie Implementierungen für alle darin enthaltenen abstrakten Methoden bereitstellen.
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. Gleiche (oder weniger eingeschränkte) Sichtbarkeit : Beim Erben von einer abstrakten Klasse müssen alle in der Klassendeklaration des Elternteils als abstrakt gekennzeichneten Methoden vom Kind definiert werden. Darüber hinaus müssen diese Methoden mit derselben (oder einer weniger eingeschränkten) Sichtbarkeit definiert werden. Wenn die abstrakte Methode beispielsweise als geschützt definiert ist, muss die Funktionsimplementierung entweder als geschützt oder öffentlich, jedoch nicht als privat definiert werden.
Beachten Sie, dass die abstrakte Methode nicht privat sein sollte.
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. Die Signaturen der abstrakten Methoden müssen übereinstimmen : Beim Erben von einer abstrakten Klasse müssen alle in der Klassendeklaration des Elternteils als abstrakt gekennzeichneten Methoden vom Kind definiert werden. Die Signaturen der Methoden müssen übereinstimmen, dh die Typhinweise und die Anzahl der erforderlichen Argumente müssen gleich sein. Wenn die untergeordnete Klasse beispielsweise ein optionales Argument definiert, bei dem die Signatur der abstrakten Methode dies nicht tut, liegt kein Konflikt in der Signatur vor.
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. Abstrakte Klasse unterstützt keine Mehrfachvererbung : Abstrakte Klasse kann eine andere abstrakte Klasse erweitern, Abstrakte Klasse kann die Implementierung der Schnittstelle bereitstellen. Sie unterstützt jedoch keine Mehrfachvererbung.
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
Hinweis: Bitte beachten Sie, dass die Reihenfolge oder Positionierung der Klassen in Ihrem Code den Interpreter beeinflussen und einen schwerwiegenden Fehler verursachen kann. Achten Sie daher bei Verwendung mehrerer Abstraktionsebenen auf die Positionierung der Klassen im Quellcode.
Das folgende Beispiel führt zu einem schwerwiegenden Fehler: Klasse 'Pferd' wurde nicht gefunden
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());