Parlons des bases de la programmation orientée objet en PHP (2)

Cet article parle principalement des fondements de la programmation orientée objet PHP (2). Il a une certaine valeur d'apprentissage. Les amis intéressés peuvent en apprendre davantage.

Dans certains petits projets, vous entrerez fréquemment en contact avec l'héritage, l'encapsulation, le polymorphisme et d'autres fonctionnalités des classes, et utiliserez les fonctions de la classe elle-même.

Mais dans les grands projets, les interfaces de classe sont souvent utilisées pour l'implémenter, car les interfaces n'impliquent pas l'implémentation de fonctions spécifiques de la classe, mais les interfaces limiteront les fonctions de la classe.

Un logiciel complexe et à grande échelle doit être composé de nombreuses classes fonctionnelles. Ces classes fonctionnelles doivent être complétées par plusieurs programmeurs. Parmi eux, l'architecte logiciel doit spécifier le mode impliqué, la division du travail en équipe. et d'autres travaux.

Cela soulève le problème de l'unité de programmation. Comment garantir que les fonctions clés peuvent être bien implémentées nécessite une interface de conception qui peut prendre en compte tous les aspects, les interfaces de classe sont généralement utilisées, bien que PHP puisse utiliser de nombreuses méthodes.

Les fonctionnalités telles que l'encapsulation, la fondation et le polymorphisme des classes impliquent toutes les fonctions des classes, qui sont généralement implémentées dans de petits projets.

Mais dans les grands projets, le logiciel doit avoir de nombreuses fonctions, ce qui nécessite de nombreuses classes fonctionnelles, et ces classes fonctionnelles sont généralement complétées par plusieurs programmeurs, donc parmi de nombreux programmeurs, le problème de la programmation unifiée se pose. s'assurer que les fonctions du logiciel peuvent être bien réalisées ?

Cela nécessite de définir un ensemble de fonctions à l'avance avant la conception du logiciel, puis les programmeurs implémentent ces fonctions une par une.

Il existe de nombreuses méthodes pouvant être utilisées en PHP, qui sont généralement implémentées à l'aide d'interfaces de classe. Un ensemble de fonctions est défini dans l'interface, mais la mise en œuvre des fonctions nécessite que les programmeurs les implémentent une par une, garantissant ainsi l'intégrité des fonctions logicielles.

1. Définition de l'interface

L'interface n'est pas une classe fonctionnelle, donc des méthodes d'implémentation de fonctions spécifiques ne peuvent pas être définies dans la classe d'interface.

Utilisez le mot-clé interface lors de la définition de l'interface, et le format de nom est : I+nom de l'interface.

Habituellement, les membres définis dans l'interface doivent être des méthodes de classes fonctionnelles et ne peuvent pas être des attributs de membre de classes fonctionnelles.

Quelques points à noter :

① Les membres de l'interface doivent avoir des autorisations d'accès globales, donc les modificateurs d'accès ne peuvent pas être ajoutés

② Les membres de l'interface ne peuvent pas utiliser de constantes, de méthodes statiques, etc. Propriétés ;

　③Les membres de l'interface ne peuvent pas définir de constructeurs.

　④Les interfaces peuvent être héritées comme les classes. Après l'héritage, la sous-interface obtiendra tous les membres de l'interface parent.

2. Implémentation de l'interface

Les interfaces ne peuvent définir que des fonctions, mais ne peuvent pas implémenter de fonctions spécifiques. Si vous souhaitez réaliser les fonctions définies dans l'interface, vous devez utiliser des classes fonctionnelles ordinaires pour les implémenter. .

Format : implémente + nom de l'interface

Remarque : Toutes les méthodes membres de l'interface doivent être définies dans la classe fonctionnelle, et personne ne peut être laissé de côté.

Ce qui suit est un exemple simple à démontrer

Dans le fichier d'interface, définissez deux interfaces Imyinterce, Imys (sous-interface Imyinterface)

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

?>

Définissez ensuite une classe fonctionnelle pour implémenter l'interface. Si vous n'avez pas compris comment implémenter la fonction, vous pouvez l'implémenter via une méthode vide. Elle ne peut pas être omise, sinon une erreur sera signalée, vous invitant. que la classe fonctionnelle contient une méthode abstraite, qui doit être accomplie.

Seules les méthodes update et select de la sous-interface Imy sont implémentées ici. Les autres méthodes ne sont pas encore implémentées et des méthodes vides sont utilisées à la place.

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

}
?>

Code de test

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

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

Effet de navigation

Afin de normaliser et d'unifier les procédures, utilisant souvent interfaces. Cependant, l'interface ne peut définir que les fonctions abstraites du programme, mais ne fournit pas de fonctions spécifiques. Les membres de classe ordinaires, tels que les constantes, les propriétés statiques et autres membres ordinaires, ne peuvent pas être définis dans l'interface.

Les classes abstraites sont conçues pour l'héritage de classe. Les membres de classe ordinaires peuvent être définis dans des classes abstraites. À ce stade, les classes abstraites sont beaucoup plus flexibles que les interfaces.

Lors de la définition d'une classe abstraite, vous devez ajouter le mot-clé abstract, puis définir les méthodes membres ordinaires dans la classe abstraite. Cette méthode ordinaire ne nécessite pas de code de fonction spécifique.

La plupart des frameworks MVC sont construits à l'aide de classes abstraites PHP. Les classes abstraites peuvent être simplement comprises comme une combinaison de classes et d'interfaces ordinaires, c'est-à-dire abstract=class+interface.

Ce que les interfaces et les classes abstraites ont en commun :

　①Ni les interfaces ni les classes abstraites ne peuvent être instanciées. Les interfaces doivent être implémentées à l'aide du mot-clé Implements, tandis que les classes abstraites utilisent le mot-clé extends des classes ordinaires. hériter.

　②Les interfaces et les classes abstraites contiennent des déclarations de méthodes qui n'ont pas encore été implémentées.

　③ Les classes dérivées doivent implémenter des méthodes non implémentées. Les classes abstraites sont des méthodes abstraites et les interfaces sont toutes membres.

La différence entre les interfaces et les classes abstraites :

　①Les classes abstraites ne peuvent pas être scellées, mais les interfaces le peuvent.

　②Les méthodes concrètes implémentées par les classes abstraites sont virtuelles par défaut, mais les méthodes de classe qui implémentent des interfaces sont réelles par défaut.

　③Les classes abstraites doivent répertorier tous les membres dans la liste des classes de base de la classe pour que les classes d'implémentation soient implémentées, mais les interfaces autorisent les méthodes vides.

Après avoir compris les concepts d'interfaces et de classes abstraites, examinons de plus près la définition et l'implémentation des classes abstraites.

在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视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!