Explication détaillée des exemples d'utilisation de l'interface et des implémentations de mots-clés d'application d'interface PHP

Les classes PHP sont à héritage unique, c'est-à-dire qu'elles ne prennent pas en charge l'héritage multiple. Lorsqu'une classe nécessite les fonctions de plusieurs classes, l'héritage est impuissant. Pour cette raison, PHP introduit la technologie d'interface de classe. L'article suivant vous présente principalement les informations pertinentes sur l'interface des mots-clés et les implémentations en PHP. Les amis dans le besoin peuvent s'y référer.

Interface PHP

La classe PHP est à héritage unique, c'est-à-dire qu'elle ne prend pas en charge l'héritage multiple lorsqu'une classe nécessite plusieurs. classes Lorsqu'il s'agit de fonctions, l'héritage est impuissant, c'est pourquoi PHP introduit la technologie d'interface de classe.

Si toutes les méthodes d'une classe abstraite sont des méthodes abstraites, qu'aucune variable n'est déclarée et que tous les membres de l'interface ont des autorisations publiques, alors ces classes abstraites spéciales sont appelées interfaces.

L'interface est définie à l'aide du mot-clé interface, et le mot-clé Implements est utilisé pour implémenter les méthodes dans l'interface, qui doivent être entièrement implémentées.

Application de l'interface en classe

1. Mot clé : interface

2. Mot clé : implémente

1. Introduction et création d'interfaces

Interface : une classe abstraite spéciale dont les membres attributssont tous abstraits ou constants.

Règles :

1. Toutes les méthodes de la classe sont abstraites.

2. Il n'est pas nécessaire d'ajouter du résumé pour les méthodes abstraites.

3. L'attribut de méthode abstraite de l'interface est public.

4. Les attributs des membres doivent être des constantes.

Le code de format est le suivant :

interface demo { 
const NAME = "常量对象属性"; 
function fun1(); 
function fun2(); //抽象方法。 
}

2. Application et spécifications des interfaces

Les références d'interface sont différentes des mots-clés d'héritage de classe 🎜>étend

class MyPc implements demo , demo2 , demo3 { 
... 
}

<🎜. >2. Format : Exemple d'interface d'application de classe abstraite

abstract class MyPc implements demo , demo2 , demo3 { 
... 
}

3. Format : Hériter de la classe parent et référencer l'interface et coexister

class MyPc extends Root implements demo , demo2 , demo3 { 
... 
}

Hériter d'abord puis l'interface, héritage unique de plusieurs interfaces.

4. Format : Héritage des interfaces et des interfaces

interface demo3 extends demo { 
... 
}

L'exemple de code est le suivant :

<?php 
interface demo { 
 const NAME = "名称"; 
 function fun1(); 
 function fun2(); 
} 
interface demo2 { 
 function fun3(); 
 function fun4(); 
} 
interface demo3 { 
 const TEST = "Test"; 
 function fun5(); 
} 
class MyPc implements demo, demo2 { 
 function fun1() { 
 echo "++++++++++<br />"; 
 } 
 function fun2() { 
 echo "----------<br />"; 
 } 
 function fun3() { 
 echo "1111111111<br />"; 
 } 
 function fun4() { 
 echo "2222222222<br />"; 
 } 
} 
class MyPs extends MyPc implements demo3 { 
 function fun5() { 
 echo "继承类后引用接口"; 
 } 
} 
$p = new MyPs; 
$p->fun1(); 
$p->fun2(); 
$p->fun3(); 
$p->fun4(); 
$p->fun5(); 
?>

Par exemple, l'interface est définie à l'aide du mot-clé interface et la clé Le mot implémente est utilisé pour implémenter les méthodes dans l'interface et doit être entièrement implémenté.

L'exemple de code est le suivant :

<?php 
//定义接口 
interface User{ 
 function getDiscount(); 
 function getUserType(); 
} 
//VIP用户 接口实现 
class VipUser implements User{ 
 // VIP 用户折扣系数 
 private $discount = 0.8; 
 function getDiscount() { 
  return $this->discount; 
 } 
 function getUserType() { 
  return "VIP用户"; 
 } 
} 
class Goods{ 
 var $price = 100; 
 var $vc; 
 //定义 User 接口类型参数，这时并不知道是什么用户 
 function run(User $vc){ 
  $this->vc = $vc; 
  $discount = $this->vc->getDiscount(); 
 $usertype = $this->vc->getUserType(); 
  echo $usertype."商品价格：".$this->price*$discount; 
 } 
} 
$display = new Goods(); 
$display ->run(new VipUser); //可以是更多其他用户类型 
?>

Exécutez l'exemple, le résultat est :

Prix du produit utilisateur VIP : 80 yuans

Ceci L'exemple montre une application PHP simple de l'interface. Dans cet exemple, l'interface utilisateur implémente la remise de l'utilisateur et la classe VipUser implémente le coefficient de remise spécifique. Enfin, la catégorie de produits Biens implémente différents devis utilisateur basés sur l'interface utilisateur.

Cet exemple se limite à démontrer l'utilisation de l'interface PHP et n'implique pas son caractère scientifique.

Implémenter plusieurs interfaces

PHP peut également implémenter plusieurs interfaces en même temps lors de l'héritage d'une classe :

class 子类 extends 父类 implemtns 接口1, 接口2, ... 
{ 
 ...... 
}

La différence entre la classe abstraite et l'interface

L'interface est une classe abstraite spéciale, qui peut également être considérée comme la spécification d'un modèle. La différence générale entre les interfaces et les classes abstraites est la suivante :

1. Si une sous-classe implémente une interface, elle doit implémenter toutes les méthodes de l'interface (qu'elles soient nécessaires ou non) ; il suffit d'implémenter la méthode Just the requise.

2. Si le nom de la méthode défini dans une interface change, alors toutes les sous-classes qui implémentent cette interface doivent mettre à jour le nom de la méthode de manière synchrone et si le nom de la méthode dans une classe abstraite change, le nom de la méthode correspondant à sa ; la sous-classe ne sera pas affectée, elle deviendra simplement une nouvelle méthode (par rapport à l'ancienne implémentation de la méthode).

3. Les classes abstraites ne peuvent être héritées que individuellement. Lorsqu'une sous-classe doit implémenter des fonctions qui doivent être héritées de plusieurs classes parents, des interfaces doivent être utilisées.

<?php
//简单定义实现接口
interface UserInterface{ //定义user接口
 function getname();
}
interface TeacherInterface{ //定义teacher接口
 function getLengthofService();
}
class User implements UserInterface{ //实现user接口
 private $name="nostop";
 public function getName(){
  return $this->name;
 }
}
class Teacher implements TeacherInterface{ //实现teacher接口
 private $age=23;
 public function getLengthofService(){
  return $this->age;
 }
}
$user=new User();
echo $user->getName().&#39;<br />&#39;;//nostop
$teacher=new Teacher();
echo $teacher->getLengthofService().&#39;<br />&#39;;//23
//继承类实现接口
class GraduResultudent extends User implements TeacherInterface{ //继承User类 实现接口
 private $teacher;
 public function construct(){  //定义构造函数
  $this->teacher=new Teacher(); //实例化Teacher对象
 }
 public function getLengthOfService(){ //实现TeacherInterface接口的方法
  return $this->teacher->getLengthOfService();
 }
}

class Result{
 public static function getUserName(UserInterface $_user){ //注意：这里面的类型变成接口类型
  echo "Name is ".$_user->getName().&#39;<br />&#39;;
 }
 public static function getLengthOfService(TeacherInterface $_teacher){ //注意：这里面的类型变成接口类型
  echo "age is ".$_teacher->getLengthOfService();
 }
}

$object=new GraduResultudent();
Result::getUserName($object); //Name is nostop
Result::getLengthOfService($object); //age is 23
echo "<br />";
//接口实现用户的折扣
interface People{ //定义接口
 function getUserType();
 function getCount();
}

class VipUser implements People{ //实现接口
 //用户折卡系数
 private $discount=0.8;
 function getUserType(){
  return "VIP用户";
 }
 function getCount(){
  return $this->discount;  
 }
}

$vip=new VipUser(); //实现化对象
echo $vip->getUserType().&#39;商品价格：&#39;.$vip->getCount()*100; //VIP用户商品价格：80

class Goods{
 var $price=100;
 var $member;
 function run(People $member){ //注意：这里面的参数类型是接口类型
  $this->member=$member;
  $discount=$this->member->getCount();
  $usertype=$this->member->getUserType();
  echo $usertype."商品价格：".$this->price*$discount;
 }
}
$display=new Goods();
$display->run(new VipUser);//VIP用户商品价格：80

?>

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!