Teilen von Beispielen für die Verwendung von Implementierungen in PHP

Die Anwendungsschlüsselwörter von Schnittstellen in PHP-Klassen sind Schnittstelle und Implementierung. Eine Schnittstelle ist ein spezielles Element. Abstrakte Klasse Der Name, die der Klasse gehörenden Methoden und die übergebenen Parameter dienen als Einschränkungen und Spezifikationen, ähnlich wie bei einer abstrakten Klasse.

Anwendung der Schnittstelle im Unterricht

1. Schlüsselwort: Schnittstelle

2. Schlüsselwort: 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 ist es nicht erforderlich, eine Zusammenfassung hinzuzufügen.

3. Das abstrakte Methodenattribut der Schnittstelle ist öffentlich.

4. Mitgliedsattribute müssen Konstanten sein.

Der Formatcode lautet wie folgt:

interface demo { 
const NAME = "常量对象属性"; 
function myfun1(); //抽象方法function myfun2(); //抽象方法,不用具体写入逻辑 }

1. Definition und Aufruf von Schnittstellen

Hinweis: Im obigen Beispiel ist zu beachten, dass der Methodenname der

<?phpinterface Cinema
{    const film = &#39;加勒比海盗&#39;;    public function show();
}class Order implements Cinema
{    public function show()
    {        echo "影院 接口开放了<br>";
    }
}$face = new Order();echo $face->show();       
echo Cinema::film;

-Schnittstelle show

lautet und die -Klasse, die die Schnittstelle erbt, andernfalls über die Methode show verfügen muss Es wird ein Fehler gemeldet. Mit anderen Worten, die Methoden der Schnittstelle sind gefälscht, und was wirklich funktioniert, sind die Methoden in der geerbten Klasse. Ist die Schnittstelle hier ein wenig der abstrakten Klasse von PHP ähnlich?Zweitens sind es die Parameterbeschränkungen relativ streng

Hinweis: Das obige Beispiel erbt die Schnittstellenklasse. Beim Aufruf der Schnittstellenmethode müssen die übergebenen Parameter mit den Parameternamen in der Schnittstelle übereinstimmen. Andernfalls wird ein Fehler gemeldet.

<?phpinterface Cinema
{    public function show(Order $show,$num);
}// 显示正常class Order implements Cinema
{    public $number=&#39;0011排&#39;;    public function show(Order $show,$num)
    {        echo $show->number.$num;
    }
}$face= new Order();$face->show(new Order,$num=&#39;3人&#39;);//输出 0011排3人

3. Vererbung zwischen Schnittstellen und Übergabe von Parametern durch Aufrufen von Schnittstellen

Erklärung: Wie Sie dem obigen Beispiel entnehmen können, ist die Schnittstelle Cinemal1 erbt Die Schnittstelle Cinemal, Klasse Order erbt die Schnittstelle Cinema1. Ich weiß nicht, ob Ihnen aufgefallen ist, dass die Klasse Order zwei Methoden enthält, eine ist show und die andere ist show1, und keine fehlt. Wenn eine fehlt, wird ein schwerwiegender Fehler gemeldet. Order

<?phpinterface Cinema
{    public function show();
}interface Cinema1 extends Cinema
{    public function show1(Order1 $object,$num);
}class Order implements Cinema1
{    public function show()
    {        echo "准备就绪<br>";
    }    public function show1(Order1 $object,$num)
    {        //var_dump($object);
        echo $object->number."$num<br>";
    }
}class Order1
{    public $number="0012排";    function fun(){        echo &#39; =================&#39;;
    }
}$show = new Order1;$show->fun();          
$test = new Order();$test->show();           
$test->show1($show,$num=&#39;6人&#39;);// 输出 ===============准备就绪0012排6人

1

in show1(Order1 $object,$num) muss denselben Namen haben wie die geerbte Stammklasse, Klasse Order1. Wenn sie unterschiedlich sind, wird ein schwerwiegender Fehler gemeldet. Was sollen wir also tun, wenn eine Schnittstelle von mehreren Klassen geerbt wird und die Klassennamen unterschiedlich sind? Dann müssen Sie self verwenden, was unten erwähnt wird

Viertens, Mehrfachvererbung einer Schnittstelle

Die obige Ausgabe

<?php
interface demo {
    const NAME = "电影名称";
    function fun1();
    function fun2();
}
interface demo2 {
    function fun3();
    function fun4();
}
interface demo3 {
    const TEST = "这里是测试Test";
    function fun5();
}
class MyDemo implements demo, demo2 {
    function fun1() {
        echo "你好";
    }
    function fun2() {
        echo "----------";
    }
    function fun3() {
        echo "我也好<br />";
    }
    function fun4() {
        echo "大家都好<br />";
    }
}
class YourDemo extends MyDemo implements demo3 {
    function fun5() {
        echo "继承类后引用接口";
    }
}
$p = new YourDemo;
$p->fun1();
$p->fun2();
$p->fun3();
$p->fun4();
$p->fun5();

Im obigen Beispiel können wir sehen, dass Schnittstellen mithilfe des Schlüsselworts „interface“ definiert werden und das Schlüsselwort „implements“ verwendet wird, um die Methoden in der Schnittstelle zu implementieren:

你好----------我也好
大家都好
继承类后引用接口

Dieses Beispiel zeigt ein PHP Schnittstelle einfache Anwendung. 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 verschiedene Benutzerzitate basierend auf der Benutzeroberfläche.

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

Abschließend zusammengefasst:

Der Unterschied zwischen abstrakten Klassen und Schnittstellen Interface ist eine spezielle abstrakte Klasse, die auch als Spezifikation eines Modells betrachtet werden kann. Der allgemeine Unterschied zwischen einer Schnittstelle und einer abstrakten Klasse ist wie folgt:

1 Wenn eine Unterklasse eine Schnittstelle implementiert, muss sie alle Methoden in der Schnittstelle implementieren (ob erforderlich oder nicht); 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.

Das obige ist der detaillierte Inhalt vonTeilen von Beispielen für die Verwendung von Implementierungen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!