Comprendre les classes, objets, classes abstraites et interfaces PHP dans un seul article

Classes et objets : classes abstraites, interfaces

Classes et interfaces abstraites : les classes et interfaces abstraites sont spéciales et ne peuvent pas être instanciées.

Classe abstraite :

Les méthodes abstraites dans les classes abstraites sont des méthodes vides sans implémentation concrète. Les classes abstraites peuvent être utilisées pour définir des définitions fonctionnelles pour les sous-classes, de sorte que les classes abstraites obligent les développeurs à hériter uniquement d'une classe parent spécifique

, puis à compléter ce dont ils ont besoin dans les fonctions spécifiques à la sous-classe héritée.

Le format syntaxique pour définir une classe abstraite est le suivant :

abstract class 类名称{
　　//抽象类的成员变量列表
　　abstract function 成员方法1([参数1]，[参数2]，……);
　　abstract function 成员方法2([参数1]，[参数2]，……);
　　//其他代码
}

Les classes abstraites sont similaires aux classes ordinaires et ont également attributs de membre et méthodes de membre, la différence est que les classes abstraites ne peuvent pas être instanciées.

Ce qui suit définit une classe abstraite simple et complète :

abstract class MyClass{ //定义抽象类
　　abstract protected function myFunction($arg); //定义抽象方法
}

PS : La définition d'une classe abstraite doit contenir au moins un mot-clé abstrait modifié et aucune méthode abstraite d'implémentation .

Le processus d'implémentation des classes abstraites :

Dans une classe abstraite, non seulement des méthodes abstraites peuvent être définies, mais certaines méthodes membres qui peuvent remplir des fonctions spécifiées peuvent également être définies comme des classes ordinaires. les sous-classes héritent Après avoir abstrait la classe, vous pouvez

référencer directement ces méthodes membres qui peuvent compléter les fonctions spécifiées.

class 子类名称 extends 抽象类名称{
　　//子类的成员变量列表
　　
　　function 抽象方法名称([参数1]，[参数2]，……){
　　    //抽象方法的具体实现
　　}
　　//其他代码
　}

PS : Lorsqu'une classe hérite d'une classe abstraite, elle doit contenir toutes les méthodes définies dans la classe abstraite, sinon une erreur se produira lors de l'exécution.

Ce qui suit est un exemple d'implémentation d'une classe abstraite :

abstract class Study{
　　abstract function printStudy($name,$lang); //定义一个抽象方法
}
 
class OneStudy extends Study { //定义子类继承于父类
　　function printStudy($name,$lang){ //抽象方法的具体实现
　　    echo $name."正在整理".$lang."……";
　　}
　}
　
class TwoStudy extends Study {
　　function printStudy($name,$lang){
　　    echo $name."正在整理".$lang."……";
    }
}
　　$first=new OneStudy();
　　$first->printStudy("大兵","PHP基础知识");
　　echo "";
　　$second=new TwoStudy();
　　$second->printStudy("小兵","SEO基础知识");

Le résultat de l'exécution de ce programme est :

Ding Bing est trier les connaissances de base de PHP... …

Xiaobing est en train de trier les bases du référencement...

Définir l'interface :

Une interface est une collection de déclarations de méthodes membres, qui ne contient que quelques méthodes membres vides ou certaines constantes de classe. Ces méthodes membres vides seront implémentées par la classe qui implémente l'interface.

Pour définir une interface, vous devez utiliser le mot-clé interface. Le format de syntaxe est le suivant :

interface 接口名称{
　　//类常量列表
　　function 成员方法1([参数1]，[参数2]，……);
　　function 成员方法2([参数1]，[参数2]，……);
　　//其他代码
}

L'interface ne pouvant pas être instanciée, il n'y a pas de méthode de construction ni de méthode de déconstruction dans le interface.Il suffit de donner un ensemble de déclarations de méthodes membres à implémenter.

Ce qui suit définit une interface simple et complète :

interface class MyClass{ //定义接口
　　public function myFunction($arg); //定义方法
}

Le processus de mise en œuvre de l'interface :

Similaire à un classe, une interface Peut également être héritée. Une interface peut hériter de plusieurs interfaces, mais une interface ne peut pas hériter d'une classe. Pour implémenter une interface, utilisez le mot-clé Implements.

Lors de l'utilisation d'une classe pour implémenter une interface, elle doit contenir au moins toutes les méthodes définies dans l'interface, sinon une erreur se produira au moment de l'exécution.

Ce qui suit est un exemple d'implémentation d'une interface :

interface IName{ //定义接口IName
　　function setName($name);
　　function getName();
　　}
　　interface IAge{ //定义接口IAge
　　function setAge($age);
　　function getAge();
　　}
　　class DaBing implements IName,IAge{ //定义实现接口的类
　　private $name;
　　private $age;
　　function setName($name){
　　$this->name=$name;
　　}
　　function getName(){
　　echo "姓名：".$this->name." ";
　　}
　　function setAge($age){
　　$this->age=$age;
　　}
　　function getAge(){
　　echo "年龄：".$this->age;
　　}
　　}
　　$obj=new DaBing();
　　$obj->setName("大兵");
　　$obj->getName();
　　$obj->setAge(25);
　　$obj->getAge();

Le résultat de l'exécution du programme est :

Nom : Soldat Âge : 25

Résumé classes et interfaces Différence :

L'utilisation des interfaces se fait grâce au mot-clé Implements. Les opérations sur les classes abstraites sont implémentées en héritant du mot-clé extends.

Les interfaces n'ont pas de données membres, mais les classes abstraites ont des données membres et les classes abstraites peuvent réaliser la fermeture des données.

Les interfaces n'ont pas de constructeurs, tandis que les classes abstraites peuvent avoir des constructeurs.

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

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

Il ne peut pas y avoir de code d'implémentation pour les méthodes membres dans les interfaces, mais il peut y avoir un code d'implémentation pour les méthodes membres dans les classes abstraites.

PS : Dans une application, si vous avez besoin d'ajouter plus de comportements à une certaine classe, vous pouvez définir une interface pour combiner ces comportements. Si vous devez réutiliser les données et le comportement d'un certain élément, vous devez définir une classe abstraite pour encapsuler ces variables et fonctions.

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!