Lassen Sie uns über die Grundlagen der objektorientierten Programmierung in PHP sprechen (2)

In diesem Artikel geht es hauptsächlich um die Grundlagen der objektorientierten PHP-Programmierung (2). Interessierte Freunde können etwas darüber lernen.

In einigen kleinen Projekten werden Sie häufig mit der Vererbung, Kapselung, Polymorphie und anderen Funktionen von Klassen in Berührung kommen und die Funktionen der Klasse selbst nutzen.

In großen Projekten werden jedoch häufig Klassenschnittstellen zur Implementierung verwendet, da Schnittstellen nicht die Implementierung spezifischer Funktionen der Klasse beinhalten, Schnittstellen jedoch die Funktionen der Klasse einschränken.

Eine komplexe und umfangreiche Software muss aus vielen Funktionsklassen bestehen, die von mehreren Programmierern ausgeführt werden müssen. Darunter muss der Softwarearchitekt den beteiligten Modus und die Arbeitsteilung des Teams festlegen und andere Aufgaben.

Dadurch entsteht das Problem der Programmiereinheit. Um sicherzustellen, dass Schlüsselfunktionen gut implementiert werden können, ist eine Designschnittstelle erforderlich, die alle Aspekte berücksichtigen kann, obwohl PHP viele Methoden verwenden kann.

Funktionen wie Kapselung, Gründung und Polymorphismus von Klassen umfassen alle die Funktionen von Klassen, die im Allgemeinen in kleinen Projekten implementiert werden.

Aber in großen Projekten muss die Software viele Funktionen haben, was viele Funktionsklassen erfordert, und diese Funktionsklassen werden normalerweise von mehreren Programmierern abgeschlossen, sodass bei vielen Programmierern das Problem der einheitlichen Programmierung auftritt Stellen Sie sicher, dass die Funktionen der Software gut realisiert werden können?

Dies erfordert, dass vor dem Software-Design eine Reihe von Funktionen definiert werden und diese Funktionen dann vom Programmierer einzeln implementiert werden.

In PHP können viele Methoden verwendet werden, die normalerweise über Klassenschnittstellen implementiert werden. In der Schnittstelle ist eine Reihe von Funktionen definiert, aber die Implementierung der Funktionen erfordert, dass Programmierer sie einzeln implementieren, um so die Integrität der Softwarefunktionen sicherzustellen.

1. Definition der Schnittstelle

Die Schnittstelle ist keine Funktionsklasse, daher können in der Schnittstellenklasse keine spezifischen Funktionsimplementierungsmethoden definiert werden.

Verwenden Sie beim Definieren der Schnittstelle das Schlüsselwort interface. Das Benennungsformat lautet: I + Schnittstellenname.

Normalerweise müssen die in der Schnittstelle definierten Mitglieder Methoden der Funktionsklasse sein und dürfen keine Mitgliedsattribute der Funktionsklasse sein.

Ein paar Punkte, die Sie beachten sollten:

① Schnittstellenmitglieder müssen über globale Zugriffsberechtigungen verfügen, daher können keine Zugriffsmodifikatoren hinzugefügt werden.

② Schnittstellenmitglieder können keine Konstanten, statischen Methoden usw. verwenden. usw. Eigenschaften;

　③Schnittstellenmitglieder können keine Konstruktoren definieren.

　④Schnittstellen können wie Klassen vererbt werden. Nach der Vererbung erhält die Unterschnittstelle alle Mitglieder der übergeordneten Schnittstelle.

2. Implementierung der Schnittstelle

Schnittstellen können nur Funktionen definieren, aber keine spezifischen Funktionen implementieren. Wenn Sie die in der Schnittstelle definierten Funktionen realisieren möchten, müssen Sie gewöhnliche Funktionsklassen verwenden, um sie zu implementieren .

Format: implementiert + Schnittstellenname

Hinweis: Alle Mitgliedsmethoden in der Schnittstelle müssen in der Funktionsklasse definiert sein und niemand darf ausgelassen werden.

Das Folgende ist ein einfaches Beispiel zur Veranschaulichung

Definieren Sie in der Schnittstellendatei zwei Schnittstellen: Imyinterce, Imys (Imyinterface-Unterschnittstelle)

<?php 
/**
*    定义接口Imyinterface
*/
interface Imyinterface{
    function add1();
    function add2($s);
    function add3($t=0);
}

//接口的继承
interface Imys extends Imyinterface{
    function del();
    function edit();
    function update($str);
    function select($id,$str);
}

?>

Definieren Sie dann eine Funktionsklasse, um die Schnittstelle zu implementieren. Wenn Sie nicht herausgefunden haben, wie Sie die Funktion implementieren, können Sie sie nicht weglassen, da sonst ein Fehler gemeldet wird Funktionsklasse enthält eine abstrakte Methode, die implementiert werden muss.

Nur ​​die Update- und Select-Methoden in der Unterschnittstelle Imy sind hier implementiert. Die anderen Methoden sind noch nicht implementiert und stattdessen werden leere Methoden verwendet.

<?php 
require "./Imyinterface.interface.php";
class MyClass implements Imys{
    function add1(){
        //空方法，暂无具体实现方法，虽然功能类继承Imys，但是接口Imys又继承Imyinterface,因此Imyinterface里的方法也必须要实现
    }
    function add2($str){
        //同上
    }
    function add3($t=0){
        //同上
    }
    function del(){
        //空方法，暂无具体实现方法
    }
    function edit(){
        //空方法，暂无具体实现方法
    }
    function update($str="字符串"){
        return $str;
    }
    function select($id=0,$str="字符串"){
        return $id.$str;
    }

}
?>

Testcode

<?php 
require "./MyClass.class.php";
header("Content-type:text/html;charset=utf-8");

$mys =new MyClass();
echo $mys->select();
?>

Browsing-Effekt

Das Obige führt ein, um Verfahren im großen Maßstab zu standardisieren und zu vereinheitlichen Softwaredesign, meist unter Verwendung von Schnittstellen. Die Schnittstelle kann jedoch nur die abstrakten Funktionen des Programms definieren, stellt jedoch keine bestimmten Funktionen bereit. Gewöhnliche Klassenmitglieder wie Konstanten, statische Eigenschaften und andere gewöhnliche Mitglieder können in der Schnittstelle nicht definiert werden.

Abstrakte Klassen sind für die Klassenvererbung konzipiert. Gewöhnliche Klassenmitglieder können in abstrakten Klassen definiert werden. An diesem Punkt sind abstrakte Klassen viel flexibler als Schnittstellen.

Beim Definieren einer abstrakten Klasse müssen Sie das Schlüsselwort abstract hinzufügen und dann normale Mitgliedsmethoden in der abstrakten Klasse definieren. Für diese gewöhnliche Methode ist kein spezifischer Funktionscode erforderlich.

Die meisten MVC-Frameworks werden mit abstrakten PHP-Klassen erstellt. Abstrakte Klassen können einfach als eine Kombination aus gewöhnlichen Klassen und Schnittstellen verstanden werden, d. h. abstrakt = Klasse + Schnittstelle.

Was Schnittstellen und abstrakte Klassen gemeinsam haben:

　①Weder Schnittstellen noch abstrakte Klassen können mit dem Schlüsselwort „implementiert“ instanziiert werden, während abstrakte Klassen das Schlüsselwort „extens“ gewöhnlicher Klassen verwenden zu erben.

　②Schnittstellen und abstrakte Klassen enthalten Methodendeklarationen, die noch nicht implementiert wurden.

　③ Abgeleitete Klassen müssen nicht implementierte Methoden implementieren, und alle Schnittstellen sind Mitglieder.

Der Unterschied zwischen Schnittstellen und abstrakten Klassen:

　①Abstrakte Klassen können nicht versiegelt werden, Schnittstellen jedoch schon.

　②Konkrete Methoden, die von abstrakten Klassen implementiert werden, sind standardmäßig virtuell, Klassenmethoden, die Schnittstellen implementieren, sind jedoch standardmäßig real.

　③Abstrakte Klassen müssen alle Mitglieder in der Basisklassenliste der Klasse auflisten, damit Implementierungsklassen implementiert werden können, aber Schnittstellen erlauben leere Methoden.

Nachdem wir die Konzepte von Schnittstellen und abstrakten Klassen verstanden haben, werfen wir einen genaueren Blick auf die Definition und Implementierung abstrakter Klassen.

在PHP中，抽象类不能为空类或普通类，至少需要提供一个抽象方法，而抽象类和抽象方法都需要关键字abstract。

例如，定义一个简单的CURD抽象类(数据库的增删改查)

<?php 
/**
*    抽象类的定义
*/
abstract class BaseClass{
    //查询，抽象方法
    abstract function query($sql);
    //插入,抽象方法
    abstract function insert($sql);
    //更新,抽象方法
    abstract function update($sql);
    //删除,抽象方法
    abstract function delete($sql);

    //数据库连接,普通类方法
    protected $link;
    //sql语句
    protected $sql;
    //结果
    protected $arr;
    protected function Conn(){
        $this->link=mysql_connect("localhost","root","123") or die("数据库连接失败").mysql_error();
        if($this->link){
            mysql_select_db("db_match",$this->link) or die("数据库选择失败").mysql_error();
        }
        return $this->link;
    }
    //关闭数据库连接,普通类方法
    protected function CloseConn(){
        mysql_close($this->link);
    }
}
?>

抽象类的实现

<?php 
require "./BaseClass.class.php";    //引入抽象类
/**
*    实现抽象类
*/

class MyClass extends BaseClass {

    //实现抽象中的抽象方法，抽象类中抽象方法：query()、insert()、update()、delete()
    function query($sql){
        $this->Conn($this->link);
        $this->sql=$sql;
        $result=mysql_query($this->sql);
        while($row=mysql_fetch_assoc($result)){
            $this->arr=$row;
        }
        $this->CloseConn($this->link);    //关闭连接
        return print_r($this->arr);
    }

    function insert($sql){
        $this->Conn($this->link);
        $this->sql=$sql;
        mysql_query($this->sql,$this->link);
        $this->CloseConn($this->link);    //关闭连接
    }

    function update($sql){
        $this->Conn($this->link);
        $this->sql=$sql;
        mysql_query($this->sql,$this->link);
        $this->CloseConn($this->link);    //关闭连接
    }
    function delete($sql){
        $this->Conn($this->link);
        $this->sql=$sql;
        mysql_query($this->sql,$this->link);
        $this->CloseConn($this->link);    //关闭连接
    }
}
?>

测试代码

<?php 
require "./MyClass.class.php";
header("Content-type:text/html;charset=utf-8");

$mys =new MyClass();
$mys->query("select * from `match`");
//输出结果：Array ( [m_id] => 8 [t1_id] => 5 [t2_id] => 6 [t1_score] => 2 [t2_score] => 1 [m_time] => 1421571600 )
$mys->insert("insert into `match`(m_id,t1_id,t2_id,t1_score,t2_score,m_time) values(9,5,3,3,3,1451571600)");
//添加成功
$mys->update("update `match` set m_time =1111111111 where m_id=9");
//修改成功
$mys->delete("delete from `match` where m_id=9");
//删除成功
?>

 相关教程：PHP视频教程

Das obige ist der detaillierte Inhalt vonLassen Sie uns über die Grundlagen der objektorientierten Programmierung in PHP sprechen (2). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!