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

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

balises : interface de classe abstraite classe abstraite et interface php

---

Introduction : C'est une question souvent posée en entretien et c'est aussi une question classique. Nous faisons de notre mieux pour citer des instructions officielles faisant autorité ou mener des expériences pour prouver l'exactitude du contenu indiqué dans cet article.

Classe abstraite

Veuillez consulter le document pour la description officielle Ce qui suit est une version simplifiée de la description officielle :

• A. la classe définie comme abstraite ne peut pas être instanciée. Toute classe doit être déclarée abstraite si au moins une méthode qu'elle contient est déclarée abstraite. (Une classe abstraite peut ne pas avoir de méthodes abstraites, mais une classe abstraite ne peut toujours pas être instanciée.) Une méthode définie comme abstraite déclare uniquement sa méthode appelante (paramètres), et ne peut pas définir son implémentation de fonction spécifique. Par exemple, lorsque

abstract class  AbstractClass
 {
    // 强制要求子类定义这些方法，且不能定义具体功能 注意没有大括号{}
     abstract protected function  getValue ();
    abstract protected function  prefixValue ( $prefix );

     // 普通方法（非抽象方法）
     public function  printOut () {
        print  $this -> getValue () .  "\n" ;
    }
}

• hérite d'une classe abstraite, la sous-classe non abstraite doit définir toutes les méthodes abstraites de la classe parent en plus l'accès ; le contrôle de ces méthodes doit être le même que dans la classe parent (ou plus détendu). Par exemple, si une méthode abstraite est déclarée comme protégée, alors la méthode implémentée dans la sous-classe doit être déclarée comme protégée ou publique et ne peut pas être définie comme privée.

• De plus, les méthodes appelant les méthodes doivent correspondre, c'est-à-dire que le type et le nombre de paramètres requis doivent être cohérents. Par exemple, la sous-classe définit un paramètre facultatif ( similaire à la fonction eat(

  b=1) Le $b est le paramètre facultatif ), mais il n'est pas inclus dans la déclaration de la méthode abstraite de la classe parent, alors il n'y a pas de conflit entre les deux déclarations. Cela s'applique également aux constructeurs depuis PHP 5.4. Les déclarations des constructeurs avant PHP 5.4 pouvaient être différentes.

• Supplément :
  

1. Les classes abstraites peuvent avoir des attributs de membre.

2. Quelqu'un a demandé : les méthodes abstraites peuvent-elles être définies comme privées ? La réponse est non, car le but des interfaces abstraites est d'abstraire le modèle de classe pour l'héritage. Elle est définie comme privée et ne peut pas être définie. être accessible de l’extérieur. Cela s’écarte de l’objectif de conception. L'erreur suivante sera signalée

abstract class Sutdent extends Human{
    abstract private function study();}

Erreur fatale : La fonction abstraite Sutdent::study() ne peut pas être déclarée privée dans D:11index.php en ligne 10

1. Les classes abstraites peuvent hériter de classes abstraites, et ne peuvent pas remplacer les méthodes abstraites des classes parentes abstraites. Un tel usage peut être compris comme une extension des classes abstraites. Par exemple,

abstract class  Human{
    abstract function eat();}abstract class Sutdent extends Human{
    abstract function study();
    //abstract function eat(); 若重写抽象父类的抽象方法eat()会报错}

Si vous remplacez la méthode abstraite de la classe parent abstraite, l'erreur suivante sera signalée

Erreur fatale : Can' t hérite de la fonction abstraite Human:: eat() (précédemment déclarée abstract dans Sutdent) dans D:11index.php en ligne 11

Interface

Définition de l'interface

• À l'aide de l'interface, vous pouvez spécifier quelles méthodes une classe doit implémenter, mais vous n'avez pas besoin de définir le contenu spécifique de ces méthodes.

• Une interface est définie via le mot-clé interface, tout comme la définition d'une classe standard, mais toutes les méthodes qui y sont définies sont vides.

• Toutes les méthodes définies dans l'interface doivent être publiques. C'est une caractéristique de l'interface Protégée et privée signalera une erreur (Erreur fatale : Type d'accès pour la méthode d'interface<.>) .

• Constante : Les constantes peuvent également être définies dans les interfaces. Les constantes d'interface sont utilisées exactement de la même manière que les constantes de classe, mais elles ne peuvent pas être remplacées par des sous-classes ou des sous-interfaces. (Il n'est pas recommandé d'utiliser cette méthode. Je n'arrive vraiment à trouver aucune signification, et il est facile de semer la confusion avec les classes abstraites)

interface Play  {  
    const LEVEL=10;  
    public function PlayLOL();  
    public function PlayFootball();  }

### Implémentation de l'interface

à implémenter Une interface, utilisant l'opérateur Implements. Les classes non abstraites doivent implémenter toutes les méthodes définies dans l'interface, sinon une erreur fatale sera signalée. Une classe peut implémenter plusieurs interfaces. Utilisez des virgules pour séparer les noms de plusieurs interfaces.

Supplément :
Vous pouvez hériter de classes abstraites et implémenter des interfaces en même temps. Les extensions doivent être écrites devant
Les classes abstraites implémentent des interfaces, et il n'est pas nécessaire de réécrire les méthodes qu'elles contiennent.

• Lors de l'implémentation de plusieurs interfaces, les méthodes des interfaces ne peuvent pas avoir le même nom.

• Les interfaces peuvent également être héritées, en utilisant l'opérateur extends.

• Pour implémenter une interface, une classe doit utiliser des méthodes qui sont exactement les mêmes que celles définies dans l'interface. Sinon, une erreur fatale en résultera.

interface Play  {  
    const LEVEL=10;  
    public function PlayLOL();  
    public function PlayFootball();  } 

interface Read  {  
    public function ReadNovel();  } 

abstract class  Human{
    abstract function eat();}//抽象类可以实现接口后不实现其方法，可以继承一个抽象类的同时实现多个接口注意必须要把extends语句写在implements前面，否则会报错abstract class Sutdent extends Human implements Play,Read{
    abstract function study();}

Héritage des interfaces

Une interface peut hériter d'une ou plusieurs interfaces, utiliser le mot-clé extends et en séparer plusieurs avec ',' , mais ne peut pas implémenter une autre interface, et bien sûr ne peut pas hériter d'une classe abstraite (erreur lors de l'héritage d'une classe abstraite :

Erreur fatale : PlayGame ne peut pas implémenter Human - ce n'est pas une interface dans D:11index.php à la ligne 10 )

interface Play  {   
    public function PlayFootball();  }interface Play1  {   
    public function PlayFootball();  }interface PlayGame extends play,Play1{  
    public function PlayLOL();  }

Résumé

Habituellement, les similitudes et les différences sont écrites ici, mais je ne les écris pas, hehe, car je pense que ce qui précède est suffisamment détaillé .

Résumons brièvement : Les classes abstraites sont généralement utilisées pour définir un type d'entité De quoi s'agit-il Elle comprend des attributs, des méthodes abstraites et des méthodes non abstraites. L'interface est utilisée pour définir ce qu'un type d'entité peut faire On pense généralement qu'elle n'a que des méthodes abstraites et que les constantes sont rarement utilisées.

Recommandations associées :

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!