Detaillierte Erläuterung der Verwendung 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 öffentliche Berechtigungen haben, dann werden diese speziellen abstrakten Klassen als Schnittstellen 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 Mitglieder und Attribute 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 Spezifikationen von Schnittstellen

Schnittstellenverweise unterscheiden sich von Schlüsselwörtern für die Klassenvererbungerweitert , die Vererbung kann nur einzeln erfolgen, während Schnittstellen das Schlüsselwort „implementiert“ auf mehrere Referenzen verwenden und diese durch Kommas trennen können

1. Format: normale Klassenreferenzschnittstelle

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

2. Format: Beispiel einer abstrakten Klassenanwendungsschnittstelle

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

3. Format: Erben Sie die übergeordnete Klasse und verweisen Sie auf die Schnittstelle, die koexistieren soll

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

Erst erben und dann die Schnittstelle einzeln Vererbung mehrerer Schnittstellen.

4. Format: Vererbung von Schnittstellen und 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 definiert Schnittstelle und der Schlüssel Das Wort „implementiert“ 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

Dies Beispiel zeigt eine einfache PHP-Anwendung der 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 abstrakter Klasse und Schnittstelle

Schnittstelle ist eine spezielle abstrakte Klasse, die auch als Spezifikation eines Modells betrachtet werden kann. 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 erforderlich oder nicht); wenn sie eine abstrakte Klasse erbt, muss sie alle Methoden in der Schnittstelle implementieren Es muss nur die erforderliche Methode implementiert werden.

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

?>

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