qu'est-ce qu'une classe abstraite en php?
Qu'est-ce qu'une classe abstraite en php? Où peut-il être utilisé?
Une classe abstraite est une classe qui contient au moins une méthode abstraite, c'est-à-dire une méthode qui ne contient aucun code, uniquement 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éritante à 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 constituent également un cas particulier de classes abstraites où TOUTES les méthodes sont abstraites.
Voir cette section du manuel PHP pour plus de détails.
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 ne contenant aucune implémentation. Les classes abstraites peuvent ne pas être instanciées et nécessitent que des sous-classes fournissent 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 contenant 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 contenant 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, elle 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 body : 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 de toutes ses méthodes abstraites.
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 la classe du parent doivent être définies par l'enfant. De plus, 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 étant 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 abstraites dans la déclaration de la classe du parent doivent être définies par l'enfant; les signatures des méthodes doivent correspondre, c'est-à-dire le nombre d'arguments requis doit être le même. Par exemple, si la classe enfant définit un argument facultatif, contrairement à la signature de la méthode abstraite, 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 la mise en œuvre d'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 peut 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 entraînera Erreur fatale: La classe 'cheval' est introuvable
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 est que partiellement implémenté par le programmeur. Il peut contenir un ou plusieurs méthodes abstraites. Une méthode abstraite est simplement une définition de fonction qui sert à dire au programmeur que le La méthode doit être implémentée dans un enfant classe.
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 contenir un corps
2. Ne peut être défini comme privé
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/>";
Sortie:
Hello World
India
Hello World test
F1 Method Call
F2 Method Call
- La classe abstraite contient seulement 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 les classes et méthodes abstraites.
- Les classes définies comme abstraites, nous ne pouvons pas créer l'objet (ne peut pas être instancié)
Une classe abstraite est comme la classe normale, elle contient des variables, elle contient des variables protégées, des fonctions, elle contient du constructeur, une seule différence est qu'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 la classe qui en hérite.
Les classes abstraites sont les classes qui ne peuvent pas être initialisées directement. Ou, dans d’autres mots, nous pouvons dire que les classes abstraites sont les classes dont l’objet ne peut pas être créé directement. Dans PHP, les classes abstraites sont définies avec le mot clé abstract.
Aussi, pour devenir une classe, 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 Classe abstraite dans PHP .