Quelle est la différence entre les classes abstraites et les interfaces php ?

Cet article vous présentera la différence entre les classes abstraites PHP et les interfaces. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Cours abstrait

Pour la description officielle, veuillez consulter le document, voici la description officielle. Une version simplifiée de la description :

• Une 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.

(Les classes abstraites ne peuvent avoir aucune méthode abstraite, mais les classes abstraites ne peuvent toujours pas être instanciées) Une méthode définie comme abstraite déclare uniquement sa méthode appelante (paramètres), ne peut pas être définie Son une fonction spécifique est réalisée.

Par exemple :

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

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

• Lors de l'héritage d'une classe abstraite, la sous-classe non abstraite doit définir toutes les méthodes abstraites de la classe parent ; être cohérent avec la classe parent identique (ou plus lâche). 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 d'appel de méthode doivent correspondre, c'est-à-dire que le type et le nombre de paramètres requis doivent être cohérents. Par exemple, si la sous-classe définit un paramètre facultatif ( est similaire à la fonction eat($a,$b=1), $b est le paramètre facultatif), mais il n'est pas inclus dans la déclaration du méthode abstraite de la classe parent, alors Il n'y a pas de conflit entre les deux instructions. 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é : une méthode abstraite peut-elle être définie comme privée ? La réponse est non, car le but de l'interface abstraite est d'abstraire le modèle de classe pour l'héritage. Elle est définie comme privée et n'est pas accessible. en externe. Si l’objectif de conception n’est pas atteint, une erreur sera signalée.

3. Les classes abstraites peuvent implémenter des interfaces et n'ont pas besoin d'implémenter les méthodes qu'elles contiennent

abstract class Sutdent extends Human
{
    abstract private function study();
}
Fatal error: Abstract function Sutdent::study() cannot be declared private in ...

4. Les classes abstraites peuvent hériter des classes abstraites, et ne peuvent pas remplacer les classes abstraites. méthode abstraite des classes parentes. Un tel usage peut être compris comme une extension des classes abstraites. Tels que

abstract class  Human
{
    abstract function eat();
}

abstract class Sutdent extends Human
{
    abstract function study();
    //abstract function eat(); 若重写抽象父类的抽象方法eat()会报错 Fatal error: Can't inherit abstract function Human::eat() (previously declared abstract in Sutdent) in ...
}

Interface

Définition de l'interface

• À l'aide d'une 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 ne vois vraiment 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();  
}

2. de l'interface

Pour implémenter une interface, utilisez 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  :

• peut hériter de classes abstraites et implémenter des interfaces en même temps, et les extensions doivent être écrites devant.
• Les classes abstraites implémentent des interfaces et il n'est pas nécessaire de recréer 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();
}

3. Héritage des interfaces

Une interface peut hériter d'une ou plusieurs interfaces, à l'aide du mot-clé extends, multiple Séparé par ',', mais vous ne pouvez pas implémenter une autre interface, et bien sûr vous ne pouvez 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 en D : 11index.php en ligne 10)

interface Play  
{   
    public function PlayFootball();  
}
interface PlayNew  
{   
    public function PlayFootballNew();  
}

interface PlayGame extends play,PlayNew
{  
    public function PlayLOL();  
}

Différence :

1. Utiliser des outils pour l'héritage d'interface et utiliser un résumé les classes s'étendent.

2. Les variables ne peuvent pas être déclarées dans les interfaces, mais les constantes de classe peuvent être déclarées dans les classes abstraites

3. Les interfaces n'ont pas de constructeurs, mais les classes abstraites le peuvent. have

4. Les méthodes des interfaces sont publiques par défaut et les méthodes des classes abstraites peuvent être modifiées avec public, protected et private

5. Une classe peut hériter de plusieurs interfaces, mais ne peut que hériter d'une classe abstraite

Recommandations associées : Tutoriel PHP

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!