Qu'est-ce qu'une classe abstraite en PHP?

Qu'est-ce qu'une classe abstraite en PHP?

Comment peut-il être utilisé?

Une classe abstraite est une classe qui contient au moins une méthode abstraite, qui est une méthode sans aucun code réel, juste le nom et les paramètres, et qui a été marquée comme "abstraite".

Le but est de fournir une sorte de modèle à hériter et de forcer la classe héritière à implémenter les méthodes abstraites.

Une classe abstraite est donc quelque chose entre une classe régulière et une interface pure. Les interfaces sont également un cas particulier de classes abstraites où TOUTES les méthodes sont abstraites.

Voir cette section du manuel PHP pour plus de références.

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());

Une classe abstraite est une classe qui n'est que partiellement implémentée par le programmeur. Il peut contenir une ou plusieurs méthodes abstraites. Une méthode abstraite est simplement une définition de fonction qui sert à indiquer au programmeur que la méthode doit être implémentée dans une classe enfant.

Il y a une bonne explication à cela ici .

Classe abstraite
1. Contient une méthode abstraite
2. Ne peut pas être directement initialisé
3. Impossible de créer un objet de classe abstraite
4. Utilisé uniquement à des fins d'héritage

Méthode abstraite
1. Ne peut pas contenir de corps
2. Ne peut pas être définie comme privée
3. Les classes enfants doivent définir les méthodes déclarées dans la classe abstraite

Exemple de code:

abstract class A {
    public function test1() {
        echo 'Hello World';
    }
    abstract protected function f1();
    abstract public function f2();
    protected function test2(){
        echo 'Hello World test';
    }
}

class B extends A {
    public $a = 'India';
    public function f1() {
        echo "F1 Method Call";
    }
    public function f2() {
        echo "F2 Method Call";
    }
}

$b = new B();
echo $b->test1() . "<br/>";
echo $b->a . "<br/>";
echo $b->test2() . "<br/>";
echo $b->f1() . "<br/>";
echo $b->f2() . "<br/>";

Production:

Hello World
India
Hello World test
F1 Method Call
F2 Method Call

• La classe abstraite ne contient que déclarer la signature de la méthode, ils ne peuvent pas définir l'implémentation.
• Les classes d'abstraction sont définies à l'aide du mot-clé abstract .
• La classe abstraite n'est pas possible d'implémenter l' héritage multiple .
• La dernière version de PHP 5 a introduit des classes et des méthodes abstraites.
• Classes définies comme abstraites, nous ne pouvons pas créer l'objet (peut ne pas être instancié)

Les classes abstraites sont les classes qui ne peuvent pas être initialisées directement. Ou en d'autres termes, nous pouvons dire que les classes abstraites sont ces classes dont l'objet ne peut pas être créé directement. En PHP, les classes abstraites sont défiées par le mot-clé abstract .

Aussi pour devenir une classe abstraite au moins une méthode de la classe doit être abstraite.

Pour le détail de la classe abstraite, vous pouvez vous référer à mon blog sur la classe abstraite en PHP .

Une classe abstraite est comme la classe normale elle contient des variables elle contient des variables protégées fonctions qu'elle contient constructeur une seule chose est différente elle contient une méthode abstraite.

La méthode abstraite signifie une méthode vide sans définition donc une seule différence dans la classe abstraite nous ne pouvons pas créer un objet de classe abstraite

Abstract doit contenir la méthode abstraite et ces méthodes doivent être définies dans sa classe héritière.