Les classes abstraites sont des classes qui contiennent une ou plusieurs méthodes abstraites. Une méthode abstraite est une méthode déclarée, mais qui ne contient aucune implémentation. Les classes abstraites ne peuvent pas être instanciées et nécessitent des sous-classes pour fournir des implémentations pour les méthodes abstraites.
1. Impossible d'instancier une classe abstraite : les classes définies comme abstraites ne peuvent pas être instanciées, et toute classe qui contient au moins une méthode abstraite doit également être abstraite.
Exemple ci-dessous:
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. Toute classe qui contient au moins une méthode abstraite doit également être abstraite : la classe abstraite peut avoir des méthodes abstraites et non abstraites, mais elle doit contenir au moins une méthode abstraite. Si une classe a au moins une méthode abstraite, alors la classe doit être déclarée abstraite.
Remarque: les traits prennent en charge l'utilisation de méthodes abstraites afin d'imposer des exigences à la classe exposante.
Exemple ci-dessous:
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. Une méthode abstraite ne peut pas contenir de corps : les méthodes définies comme abstraites déclarent simplement la signature de la méthode - elles ne peuvent pas définir l'implémentation. Mais une méthode non abstraite peut définir l'implémentation.
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. Lors de l'héritage d'une classe abstraite, toutes les méthodes marquées abstraites dans la déclaration de classe du parent doivent être définies par l'enfant : Si vous héritez d'une classe abstraite, vous devez fournir des implémentations à toutes les méthodes abstraites qu'elle contient.
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. Visibilité identique (ou moins restreinte) : lors de l'héritage d'une classe abstraite, toutes les méthodes marquées abstraites dans la déclaration de classe du parent doivent être définies par l'enfant; en outre, ces méthodes doivent être définies avec la même visibilité (ou une visibilité moins restreinte). Par exemple, si la méthode abstraite est définie comme protégée, l'implémentation de la fonction doit être définie comme protégée ou publique, mais pas privée.
Notez que la méthode abstraite ne doit pas être privée.
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. Les signatures des méthodes abstraites doivent correspondre : lors de l'héritage d'une classe abstraite, toutes les méthodes marquées abstract dans la déclaration de classe du parent doivent être définies par l'enfant; les signatures des méthodes doivent correspondre, c'est-à-dire les indices de type et le nombre de les arguments doivent être les mêmes. Par exemple, si la classe enfant définit un argument facultatif, alors que la signature de la méthode abstraite ne le fait pas, il n'y a pas de conflit dans la signature.
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 abstraite ne prend pas en charge l'héritage multiple : la classe abstraite peut étendre une autre classe abstraite, la classe abstraite peut fournir l'implémentation de l'interface. Mais elle ne prend pas en charge l'héritage multiple.
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
Remarque: veuillez noter que l'ordre ou le positionnement des classes dans votre code peuvent affecter l'interpréteur et provoquer une erreur fatale. Ainsi, lorsque vous utilisez plusieurs niveaux d'abstraction, faites attention au positionnement des classes dans le code source.
L'exemple ci-dessous provoquera une erreur fatale: la classe 'cheval' n'a pas été trouvée
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());