Explication détaillée de l'interface PHP et exemple de code d'utilisation de classe abstraite

1. Cours abstraitCours abstrait

1. Une classe abstraite fait référence à une classe avec le mot-clé abstrait ajouté avant la classe et une méthode abstraite (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.

Le code est le suivant :

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

Le code est le suivant :

Class B extends A{};

Alors le programme aura l'erreur suivante :

Le code est le suivant :

 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() dans B peut être publique ou protégée, mais elle ne peut pas être privée

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

interface 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 les fonctions, pas le contenu de l'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, les interfaces peuvent déclarer des variables constantes. Mais placer des variables constantes dans une interface viole son objectif d'exister en tant qu'interface et confond également les différentes valeurs des interfaces et des classes. Si vous en avez vraiment besoin, vous pouvez le mettre dans la classe abstraite ou la classe correspondante.

Le code est le suivant :

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

Le code est le suivant :

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

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

Le code est le suivant :

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.

Le code est le suivant :

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 peut hériter de plusieurs

Le code est le suivant :

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 interfaces

1. Similitudes :

(1) Les deux sont des classes abstraites et aucune ne peut être instanciée.

(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, utiliser des implémentations, tandis que la classe abstraite doit être héritée, utiliser des extensions.

(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 les relations de propriété.

(4) Bien que les classes d'implémentation d'interface et les sous-classes de classes abstraites doivent implémenter les méthodes abstraites correspondantes, les formes d'implémentation sont différentes. Chaque méthode de l'interface est une méthode abstraite, qui n'est qu'une déclaration (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 les sous-classes doivent les implémenter. 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 et pour les méthodes abstraites, elle peut choisir d'implémenter ou ; L'implémentation peut être laissée à ses sous-classes, 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é avant que la méthode abstraite dans l'interface ne soit utilisée. 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. La méthode abstraite dans une classe abstraite doit être précédée de abstract pour indiquer qu'elle est explicitement déclarée comme méthode abstraite.

(7) La méthode abstraite dans l'interface est publique par défaut et ne peut être publique qu'elle ne peut pas être modifiée 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 la sous-classe peut choisir les méthodes qu'elle souhaite couvrir.

(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 du résumé peut bien servir cela.

(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.

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!