Explication détaillée des classes abstraites et des interfaces en PHP

Cet article partage principalement avec vous l'explication détaillée des classes abstraites et des interfaces en PHP, dans l'espoir d'aider tout le monde.

1. Classe abstraite classe abstraite

1. Une classe abstraite fait référence à une classe avec le mot-clé abstrait ajouté avant la classe et une méthode abstraite (le mot-clé abstrait ajouté avant le mot-clé fonction de la méthode de classe).

2． Les classes abstraites ne peuvent pas être instanciées directement. La classe abstraite définit uniquement (ou implémente partiellement) les méthodes requises par la sous-classe. Les sous-classes peuvent rendre concrète une classe abstraite en en héritant et en implémentant toutes les méthodes abstraites de la classe abstraite.

3． Si une sous-classe doit être instanciée, elle doit implémenter toutes les méthodes abstraites de la classe abstraite. Si la sous-classe n'implémente pas toutes les méthodes abstraites de la classe abstraite, alors la sous-classe est également une classe abstraite et doit être précédée du mot-clé abstract dans la classe et ne peut pas être instanciée.

abstract class A  
{  
    /** 抽象类中可以定义变量 */  
    protected $value1 = 0;  
    private $value2 = 1;  
    public $value3 = 2;  
    /** 也可以定义非抽象方法 */  
    public function my_print()  
    {  
        echo "hello,world/n";  
    }  
    /** 
     * 大多数情况下，抽象类至少含有一个抽象方法。抽象方法用abstract关键字声明，其中不能有具体内容。 
     * 可以像声明普通类方法那样声明抽象方法，但是要以分号而不是方法体结束。也就是说抽象方法在抽象类中不能被实现，也就是没有函数体“{some codes}”。 
     */  
    abstract protected function abstract_func1();  
    abstract protected function abstract_func2();  
}  
abstract class B extends A  
{  
    public function abstract_func1()  
    {  
       echo "implement the abstract_func1 in class A/n";  
    }  
    /** 这么写在zend studio 8中会报错*/  
    //abstract protected function abstract_func2();  
}  
class C extends B  
{  
    public function abstract_func2()  
    {  
       echo "implement the abstract_func2 in class A/n";  
    }  
}

4． Si vous créez une sous-classe B qui hérite de A comme suit, mais n'implémente pas la méthode abstraite abstract_func() :

Class B extends A{};

• 
  

Ensuite, le programme aura l'erreur suivante :

Fatal error: Class B contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (A::abstract_func)

5. Si B implémente la méthode abstraite abstract_func(), alors le contrôle d'accès de la méthode abstract_func() dans B ne peut pas être plus strict que le contrôle d'accès de abstract_func() dans A, c'est-à-dire :

(1) Si abstract_func dans A () est déclaré public, alors la déclaration de abstract_func() dans B ne peut être que publique, non protégée ou privée

(2) Si abstract_func() dans A est déclaré comme protégé, alors la déclaration de abstract_func() en B La déclaration peut être publique ou protégée, mais ne peut pas être privée

(3) Si abstract_func() en A est déclarée comme privée, hehe, elle ne peut pas être définie comme privée ! (Erreur fatale : la fonction abstraite A::abstract_func() ne peut pas être déclarée privée)

2. Interface d'interface

1. Les classes abstraites fournissent des normes pour une implémentation concrète, tandis que les interfaces sont de purs modèles. Les interfaces définissent uniquement des fonctions et ne contiennent pas de contenu d'implémentation. Les interfaces sont déclarées avec le mot-clé interface.

2． L'interface est complètement abstraite. Elle ne peut déclarer que des méthodes et uniquement des méthodes publiques. Elle ne peut pas déclarer de méthodes privées et protégées, ne peut pas définir de corps de méthode et ne peut pas déclarer de variables d'instance. Cependant, l'interface peut déclarer des variables constantes. Mais placer des variables constantes dans l'interface viole le but de son existence en tant qu'interface et confond également les différentes valeurs de l'interface et des classes. Si vous en avez vraiment besoin, vous pouvez le mettre dans la classe abstraite ou la classe correspondante.

interface iA  
{  
    const AVAR=3;  
    public function iAfunc1();  
    public function iAfunc2();  
}  
echo iA:: AVAR;

3． Toute classe qui implémente une interface doit implémenter toutes les méthodes définies dans l'interface

class E implements iA  
{  
    public function iAfunc1(){echo "in iAfunc1";}  
    public function iAfunc2(){echo "in iAfunc2";}  
}

• 
  

Sinon la classe doit être déclarée abstract .

1. abstract class E implements iA{}

4. Une classe peut implémenter une interface en utilisant le mot clé Implements dans sa déclaration. Après cela, le processus spécifique d'implémentation de l'interface est le même que l'héritage d'une classe abstraite qui ne contient que des méthodes abstraites. Une classe peut hériter d'une classe parent et implémenter n'importe quel nombre d'interfaces en même temps. La clause extends doit précéder la clause Implements. PHP ne prend en charge que l'héritage d'une classe parent, le mot-clé extends ne peut donc être suivi que d'un nom de classe.

1. interface iB  
   {  
       public function iBfunc1();  
       public function iBfunc2();  
   }  
   class D extends A implements iA,iB  
   {  
       public function abstract_func1()  
       {  
          echo "implement the abstract_func1 in class A/n";  
       }  
       public function abstract_func2()  
       {  
          echo "implement the abstract_func2 in class A/n";  
       }  
       public function iAfunc1(){echo "in iAfunc1";}  
       public function iAfunc2(){echo "in iAfunc2";}  
       public function iBfunc1(){echo "in iBfunc1";}  
       public function iBfunc2(){echo "in iBfunc2";}  
   }  
      
   class D extends B implements iA,iB  
   {  
       public function abstract_func1()  
       {  
          parent::abstract_func1();  
          echo "override the abstract_func1 in class A/n";  
       }  
       public function abstract_func2()  
       {  
          echo "implement the abstract_func2 in class A/n";  
       }  
       public function iAfunc1(){echo "in iAfunc1";}  
       public function iAfunc2(){echo "in iAfunc2";}  
       public function iBfunc1(){echo "in iBfunc1";}  
       public function iBfunc2(){echo "in iBfunc2";}  
   }

5． Une interface ne peut pas implémenter une autre interface, mais elle peut hériter de plusieurs

1. interface iC extends iA,iB{}  
   class F implements iC  
   {  
       public function iAfunc1(){echo "in iAfunc1";}  
       public function iAfunc2(){echo "in iAfunc2";}  
       public function iBfunc1(){echo "in iBfunc1";}  
       public function iBfunc2(){echo "in iBfunc2";}  
   }

3. Similitudes et différences entre les classes abstraites et les interfaces

1 . Similitudes :

(1) Les deux sont des classes abstraites et ne peuvent pas être instanciées.

(2) La classe d'implémentation d'interface et les sous-classes de la classe abstraite doivent implémenter les méthodes abstraites déclarées.

2. Différences :

(1) L'interface doit être implémentée, en utilisant Implements , tandis que la classe abstraite doit être héritée, en utilisant extends .

(2) Une classe peut implémenter plusieurs interfaces, mais une classe ne peut hériter que d'une seule classe abstraite.

(3) L'interface met l'accent sur la mise en œuvre de fonctions spécifiques, tandis que la classe abstraite met l'accent sur la relation de propriété.

(4) Bien que les classes d'implémentation d'interface et les sous-classes de classe abstraite doivent implémenter les méthodes abstraites correspondantes, les formes d'implémentation sont différentes. Chaque méthode dans l'interface est une méthode abstraite, qui est uniquement déclarée (déclaration, pas de corps de méthode) et la classe d'implémentation doit l'implémenter. Les sous-classes de la classe abstraite peuvent être implémentées de manière sélective. Ce choix a deux implications : a) Toutes les méthodes de la classe abstraite ne sont pas abstraites. Seules les méthodes avec abstract sont abstraites et doivent être implémentées par des sous-classes. Pour les méthodes sans résumé, le corps de la méthode doit être défini dans la classe abstraite ; b) Lorsqu'une sous-classe de la classe abstraite en hérite, elle peut directement hériter ou remplacer les méthodes non abstraites ; être laissé à ses sous-classes pour l'implémentation, mais cette classe doit également être déclarée abstraite. Puisqu’il s’agit d’une classe abstraite, elle ne peut bien sûr pas être instanciée.

(5) La classe abstraite est l'intermédiaire entre l'interface et la classe. la classe abstraite joue un rôle de connexion dans l'interface et la classe. D'une part, la classe abstraite est abstraite et peut déclarer des méthodes abstraites pour standardiser les fonctions que les sous-classes doivent implémenter. D'autre part, elle peut définir des corps de méthode par défaut pour une utilisation directe ou un remplacement par les sous-classes. De plus, il peut définir ses propres variables d'instance à utiliser par les sous-classes via l'héritage.

(6) Le mot-clé abstract ne peut pas être ajouté devant la méthode abstraite dans l'interface. La méthode abstraite est implicite par défaut, et le mot-clé final ne peut pas être ajouté pour empêcher l'héritage des méthodes abstraites. Dans une classe abstraite, abstract doit être ajouté avant la méthode abstraite pour indiquer qu'elle est explicitement déclarée comme méthode abstraite.

(7) Les méthodes abstraites dans les interfaces sont publiques par défaut et ne peuvent être publiques qu'elles ne peuvent pas être modifiées avec des modificateurs privés ou protégés. Les méthodes abstraites des classes abstraites peuvent être modifiées avec public et protected, mais ne peuvent pas être modifiées avec private.

3. Occasions d'application de l'interface

(1) Les classes ont besoin d'interfaces spécifiques pour la coordination, quelle que soit la manière dont elles sont mises en œuvre.

(2) existe en tant qu'identifiant qui peut implémenter une fonction spécifique, ou il peut s'agir d'un pur identifiant sans aucune méthode d'interface.

(3) Il est nécessaire de traiter un groupe de classes comme une seule classe, et l'appelant ne contacte ce groupe de classes que via l'interface.

(4) Il est nécessaire d'implémenter plusieurs fonctions spécifiques, et ces fonctions peuvent n'avoir aucun lien.

4. Occasions d'application de la classe abstraite

En un mot, vous pouvez l'utiliser lorsque vous avez besoin à la fois d'une interface unifiée et de variables d'instance ou de méthodes par défaut. Les plus courants sont :

(1) définit un ensemble d'interfaces, mais ne veut pas forcer chaque classe d'implémentation à implémenter toutes les interfaces. Vous pouvez utiliser une classe abstraite pour définir un ensemble de corps de méthode, ou même des corps de méthode vides, puis laisser les sous-classes choisir les méthodes qui les intéressent.

(2) Dans certains cas, les interfaces pures ne peuvent à elles seules satisfaire la coordination entre les classes. Des variables représentant les états de la classe sont également nécessaires pour distinguer différentes relations. Le rôle intermédiaire de l’abstrait peut très bien y répondre.

(3) Standardise un ensemble de méthodes mutuellement coordonnées, dont certaines sont communes, indépendantes de l'état et peuvent être partagées sans qu'il soit nécessaire que les sous-classes les implémentent séparément, tandis que d'autres méthodes nécessitent que chaque sous-classe les implémente ; selon son propre état spécifique pour réaliser des fonctions spécifiques.

Recommandations associées :

Résumé des classes et interfaces abstraites

Modèle de conception PHP 2 : classes et interfaces abstraites

La différence entre les classes abstraites php et les interfaces

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!