Explication détaillée des interfaces, des classes abstraites et des différences entre les interfaces et les classes abstraites en PHP

En php, les classes abstraites d'interface, Final et Static sont assez simples, particulièrement utiles dans l'architecture de sites Web à grande échelle. Aujourd'hui, nous examinerons un article sur les exemples de classes abstraites de php. , Final et Statique.

1. Interface
(1) L'utilisation de l'interface se fait via le mot-clé Implements
(2) L'interface ne peut pas définir de variables membres (y compris les variables statiques de classe), mais peut définir des constantes
(3) Les sous-classes doivent implémenter toutes les méthodes définies par l'interface
(4) L'interface peut uniquement définir mais pas implémenter la méthode
(5) L'interface n'a pas de constructeur
( 6) Méthodes dans l'interface Et la classe qui l'implémente est de type public par défaut
2 Classe abstraite
(1) L'utilisation de la classe abstraite se fait via le mot-clé extends
. (2) Il ne peut pas être instancié, vous pouvez définir les méthodes que la sous-classe doit implémenter
(3) La sous-classe doit définir toutes les méthodes abstraites de la classe parent, et le contrôle d'accès de ces méthodes doit être le même (ou plus détendu) comme dans la classe parent
(4) S'il y a une méthode abstraite dans une classe, la classe doit être définie comme une classe abstraite
(5) Une classe abstraite peut avoir un constructeur
(6 ) Les méthodes d'une classe abstraite peuvent être modifiées avec private, protected et public.
(7) Une classe peut implémenter plusieurs interfaces en même temps, mais une classe ne peut hériter que d'une seule classe abstraite.
3. Classe/méthode finale
(1) La classe finale ne peut pas être héritée
(2) La méthode finale ne peut pas être remplacée
4 Classe/méthode statique
(1) Impossible. être instancié Classer et accéder directement à
(2) Les propriétés statiques ne sont pas accessibles aux objets via l'opérateur -> Utilisez la méthode :: pour appeler

exemple

<?php
# 接口
interface Human{
    const TEST_CONST = "test const"; // 定义常量
    // public $v; // error，不能定义变量
    // static $count; // error，不能定义变量
    public function speak();
    public function walk();
    public function run();
}
     
# 抽象类
abstract class Father implements Human{
     
    public function construct(){
        echo "father init n";
    }
     
    abstract public function walk(); // 抽象方法
     
    public function speak(){
        echo "father speak skill n";
    }
     
    public function run(){
        echo "father run skill n";
    }
}
     
# 非抽象类
class Mother implements Human{
     
    public function construct(){
        echo "mother init n";
    }
     
    # 这里必须实现walk方法
    public function walk(){
        echo "mother walk skill n"; 
    } 
     
    public function speak(){
        echo "mother speak skill n";
    }
     
    public function run(){
        echo "mother run skill n";
    }
}
     
class Son extends Father{
     
    public function walk(){
        echo "son walk skill. n";
    }
     
    public function speak($name = &#39;&#39;){
        echo "son: ". $name ." speak skill. n";
    }
     
    # 访问控制必须和父类中一样（或者更为宽松）
    protected function sport(){
        echo "son sport skill. n";
    }
     
    final public function notTeach(){
        echo &#39;son has not to teach skill&#39;;
    }
}
     
class Daughter extends Mother{
     
    public function run($name = &#39;&#39;){
        echo "daughter run skill. n";
    }
     
}
     
final class GrandChild extends Son{
         
    # 访问控制必须和父类中一样（或者更为宽松）
    public function sport(){
        echo "GrandChild sport skill. n";
    }
     
    # Cannot override final method Son::notTeach()
    // public function notTeach(){} // error
}
     
#  Class Orphan may not inherit from final class (GrandChild)
// class Orphan extends GrandChild{}  // error
     
$son = new Son();
$son->speak("Suly");
     
$daughter = new Daughter();
$daughter->run(&#39;Lily&#39;);
     
$grandChild = new GrandChild();
$grandChild->sport();

<.> La différence entre les classes abstraites et les interfaces

1. L'utilisation des interfaces se fait via le mot clé Implements. L'utilisation de classes abstraites se fait via le mot-clé extends. Bien entendu, les interfaces peuvent également être héritées via le mot-clé extends.

2. Les variables membres (y compris les variables statiques de classe) ne peuvent pas être déclarées dans l'interface, mais les constantes de classe peuvent être déclarées. Différents types de variables membres peuvent être déclarés dans des classes abstraites pour implémenter l'encapsulation des données. (De plus, les variables membres de l'interface JAVA doivent être déclarées comme type final statique public)
3. L'interface n'a pas de constructeur, mais la classe abstraite peut avoir un constructeur.

4. Les méthodes des interfaces sont de type public par défaut, tandis que les méthodes des classes abstraites peuvent être modifiées avec private, protected ou public.

5. Une classe peut implémenter plusieurs interfaces en même temps, mais une classe ne peut hériter que d'une seule classe abstraite.

Classe ou interface abstraiteSi vous souhaitez créer un modèle qui sera adopté par certains objets étroitement liés, vous pouvez utiliser des classes abstraites. Utilisez des interfaces si vous souhaitez créer des fonctionnalités qui seront adoptées par un certain nombre d'objets non liés.
Si le comportement doit être hérité de plusieurs sources, utilisez des interfaces.
Si vous savez que toutes les classes partageront une implémentation de comportement commune, utilisez une classe abstraite et implémentez ce comportement en son sein.

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!