Detaillierte grafische Erläuterung der Schlüsselwortschnittstelle und der Implementierungen in PHP

PHP-Klassen sind Einzelvererbungen, das heißt, sie unterstützen keine Mehrfachvererbung. Wenn eine Klasse die Funktionen mehrerer Klassen benötigt, ist die Vererbung machtlos. Aus diesem Grund führt PHP die Klassenschnittstellentechnologie ein. Der folgende Artikel stellt Ihnen hauptsächlich die relevanten Informationen zur Schlüsselwortschnittstelle und zur Implementierung in PHP vor. Freunde, die sie benötigen, können einen Blick darauf werfen.

PHP-Schnittstelle

Die PHP-Klasse ist eine Einzelvererbung, das heißt, sie unterstützt keine Mehrfachvererbung, wenn eine Klasse mehrere Vererbungen erfordert Klassen Wenn es um Funktionen geht, ist die Vererbung machtlos, daher führt PHP die Klassenschnittstellentechnologie ein.

Wenn alle Methoden in einer abstrakten Klasse abstrakte Methoden sind und keine Variablen deklariert sind und alle Mitglieder in der Schnittstelle über öffentliche Berechtigungen verfügen, wird diese spezielle abstrakte Klasse als Schnittstelle bezeichnet.

Die Schnittstelle wird mit dem Schlüsselwort „interface“ definiert, und das Schlüsselwort „implements“ dient zur Implementierung der Methoden in der Schnittstelle, die vollständig implementiert sein müssen.

Anwendung der Schnittstelle im Unterricht

1. Stichwort: Schnittstelle

2. Stichwort: implementiert

1. Einführung und Erstellung von Schnittstellen

Schnittstelle: eine spezielle abstrakte Klasse, deren Mitgliedsattribute alle abstrakt oder konstant sind.

Regeln:

1. Alle Methoden in der Klasse sind abstrakt.

2. Für abstrakte Methoden muss kein Abstract hinzugefügt werden.

3. Das abstrakte Methodenattribut der Schnittstelle ist öffentlich.

4. Mitgliedsattribute müssen Konstanten sein.

Der Formatcode lautet wie folgt:

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

2. Anwendung und Spezifikation der Schnittstelle

Schnittstellenreferenz Anders als beim Klassenvererbungsschlüsselwort „extends“ kann die Vererbung nur einzeln erfolgen, während die Schnittstelle das Schlüsselwort „implements“ verwenden kann, um mehrere durch Kommas getrennte Referenzen zu haben

1 Format: normale Klassenreferenzschnittstelle

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

2. Format: Beispiel für eine abstrakte Klassenanwendung

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

3 Referenzschnittstelle und Koexistenz

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

Zuerst erben und dann Schnittstelle, einzelne Vererbung mehrerer Schnittstellen.

4. Format: Schnittstelle und Vererbung von Schnittstellen

interface demo3 extends demo { 
... 
}

Der Beispielcode lautet wie folgt:

<?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(); 
?>

Zum Beispiel wird die Schnittstelle mit dem Schlüsselwort „interface“ definiert, und das Schlüsselwort „implements“ wird zum Implementieren der Methoden in der Schnittstelle verwendet und muss vollständig implementiert sein.

Der Beispielcode lautet wie folgt:

<?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); //可以是更多其他用户类型 
?>

Führen Sie das Beispiel aus, die Ausgabe lautet:

VIP-Benutzerproduktpreis : 80 Yuan

Dieses Beispiel zeigt eine einfache Anwendung einer PHP-Schnittstelle. In diesem Beispiel implementiert die Benutzeroberfläche den Rabatt des Benutzers und die VipUser-Klasse implementiert den spezifischen Rabattkoeffizienten. Schließlich implementiert die Produktkategorie Waren unterschiedliche Benutzerangebote basierend auf der Benutzeroberfläche.

Dieses Beispiel beschränkt sich auf die Demonstration der Verwendung der PHP-Schnittstelle und geht nicht auf deren wissenschaftlichen Charakter ein.

Mehrere Schnittstellen implementieren

PHP kann beim Erben einer Klasse auch mehrere Schnittstellen gleichzeitig implementieren:

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

Der Unterschied zwischen abstrakten Klassen und Interfaces

Interfaces sind spezielle abstrakte Klassen und können auch als Spezifikation eines Modells betrachtet werden. Der allgemeine Unterschied zwischen Schnittstellen und abstrakten Klassen ist wie folgt:

1. Wenn eine Unterklasse eine Schnittstelle implementiert, muss sie alle Methoden in der Schnittstelle implementieren (ob benötigt oder nicht); wenn sie eine abstrakte Klasse erbt, muss sie alle Methoden in der Schnittstelle implementieren Es muss nur die erforderliche Methode implementiert werden. Verwenden Sie einfach die Methode.

2. Wenn sich der in einer Schnittstelle definierte Methodenname ändert, müssen alle Unterklassen, die diese Schnittstelle implementieren, den Methodennamen synchron aktualisieren, und wenn sich der Methodenname in einer abstrakten Klasse ändert, muss der entsprechende Methodenname aktualisiert werden Die Unterklasse wird davon nicht betroffen sein, sie wird lediglich zu einer neuen Methode (relativ zur alten Methodenimplementierung).

3. Abstrakte Klassen können nur einzeln geerbt werden. Wenn eine Unterklasse Funktionen implementieren muss, die von mehreren übergeordneten Klassen geerbt werden müssen, müssen Schnittstellen verwendet werden.

<?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

?>

Verwandte Empfehlungen:

Über PHP inGeräten

Detaillierte Erläuterung der Verwendung von Geräten in PHP

implementiert in PHP Gebrauchsanweisung

Das obige ist der detaillierte Inhalt vonDetaillierte grafische Erläuterung der Schlüsselwortschnittstelle und der Implementierungen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!