Vertieftes Verständnis der objektorientierten PHP-, Muster- und Praxis-erweiterten Funktionen (2)

Abstrakte Klasse

Abstrakte Klasse kann nicht direkt instanziiert werden. Abstrakte Klassen definieren (oder implementieren) nur die von Unterklassen benötigten Methoden. Unterklassen können es erben und die abstrakte Klasse konkretisieren, indem sie ihre abstrakten Methoden implementieren. Sie können eine abstrakte Klasse mit dem Schlüsselwort abstract definieren. In den meisten Fällen enthalten abstrakte Klassen mindestens eine abstrakte Methode. Abstrakte Methoden werden mit dem Schlüsselwort abstract deklariert und können keinen bestimmten Inhalt haben.

abstract class ShopProductWriter{
    protected $products = array();   
     public function addProduct(ShopProduct $shopProduct)
    {
        $this->products[] = $shopProduct;
    }    abstract public function write();}

Stellen Sie nach dem Erstellen einer abstrakten Methode sicher, dass die Methode in allen Unterklassen implementiert ist, die Implementierungsdetails jedoch noch nicht bestimmt werden können. Jede Unterklasse muss alle abstrakten Methoden in der abstrakten Klasse implementieren oder sich selbst als abstrakte Methoden deklarieren. Die erweiterte Klasse ist nicht nur für die einfache Implementierung der Methoden in der abstrakten Klasse verantwortlich, sondern muss die Methoden auch neu deklarieren. Die Zugriffskontrolle der neuen Implementierungsmethode kann nicht strenger sein als die Zugriffskontrolle der abstrakten Methode. Die Anzahl der Parameter der neuen Implementierungsmethode sollte mit der Anzahl der Parameter der abstrakten Methode übereinstimmen und die entsprechenden Typhinweise sollten neu generiert werden.

class XmlProductWriter extends ShopProductWriter{

    public function write()
    {
        $str=&#39;<?xml version="1.0" encoding="UTF-8"?>&#39;."\n";        
        $str.="<products>\n";        
        foreach ($this->products as $shopProduct) {            
        $str.="\t<product title=\"{$shopProduct->getTitle()}\">\n";            
        $str.="\t\t<summary>\n";            
        $str.="\t\t{$shopProduct->getSummaryLine()}\n";            
        $str.="\t\t</summary>\n";            
        $str.="\t</product>\n";
        }        
        $str.="</products>\n";        
        print $str;
    }
}class TextProductWriter extends ShopProductWriter{

    public function write()
    {
        $str="PRODUCTS:\n";        
        foreach ($this->products as $shopProduct) {            
        $str.=$shopProduct->getSummaryLine()."\n";
        }        
        print $str;
    }
}

Schnittstelle

Abstrakte Klassen stellen spezifische Implementierungsstandards bereit, während Schnittstellen reine Vorlagen sind. Schnittstellen können nur Funktionen definieren, keinen Implementierungsinhalt. Schnittstellen können mit dem Schlüsselwort interface deklariert werden. Schnittstellen können Eigenschafts- und Methoden--Deklarationen enthalten, der Methodenkörper ist jedoch leer.

interface Chargeable{
    public function getPrice();}

Jede Klasse, die eine Schnittstelle implementiert, muss alle in der Schnittstelle definierten Methoden implementieren, andernfalls muss die Klasse als abstrakt deklariert werden. Eine Klasse kann eine Schnittstelle mithilfe des Schlüsselworts „implementieren“ in ihrer Deklaration implementieren.

class ShopProduct implements Chargeable
{
    //...
    function getPrice()
    {        return ($this->getPrice-$this->discount);
    }
    //...}

Die ShopProduct-Klasse verfügt bereits über eine getPrice()-Methode. Ist es also noch sinnvoll, die Chargeable-Schnittstelle zu implementieren? Die Antwort lautet ja, aufgrund der Typen. Eine Klasse, die eine Schnittstelle implementiert, akzeptiert den Typ der von ihr geerbten Klasse und der von ihr implementierten Schnittstelle.

Jede Klasse kann eine Schnittstelle implementieren, und Schnittstellen können nicht verwandte Typen effektiv verbinden. Eine Klasse kann eine übergeordnete Klasse erben und beliebig viele Schnittstellen gleichzeitig implementieren. Die Extens-Klausel steht vor der Implements-Klausel.

class Consultancy extends TimedService implements Bookable, Chargeable{//...}

Verzögerte statische Bindung: statisches Schlüsselwort

Das offensichtlichste Zeichen dieser Funktion ist das neue Schlüsselwort static. static ähnelt self, bezieht sich jedoch auf die aufgerufene Klasse und nicht auf die enthaltende Klasse. In diesem Fall bedeutet dies, dass der Aufruf von Document::create() ein neues Document-Objekt generiert, anstatt zu versuchen, ein DomainObject-Objekt zu instanziieren.

abstract class DomainObject{

    public static function create()
    {
        return new static();
    }
}class User extends DomainObject{   }class Document extends DomainObject{}

print_r(Document::create());//输出为Document Object//      (//      )

Das Schlüsselwort static kann nicht nur zur Instanziierung verwendet werden. Wie self und parent kann auch static als Bezeichner für statische Methodenaufrufe verwendet werden, auch aus nicht statischen Kontexten.

abstract class DomainObject{
    private $group;    public function construct()
    {
        $this->group=static::getGroup();
    }    public static function create()
    {
        return new static();
    }    static function getGroup(){
        return "default";
    }
}class User extends DomainObject{   }class Document extends DomainObject{
    static function getGroup(){
        return "document";
    }
}class SpreadSheet extends Document{}

print_r(User::create());
print_r(SpreadSheet::create());//输出为User Object//      
(//          
[group:DomainObject:private]=>default
//      
)//      
SpreadSheet Object//      
(//          
[group:DomainObject:private]=>document//      
)

Das obige ist der detaillierte Inhalt vonVertieftes Verständnis der objektorientierten PHP-, Muster- und Praxis-erweiterten Funktionen (2). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!