Une brève discussion sur la programmation orientée objet en PHP

Le contenu de cet article concerne une brève discussion sur la programmation orientée objet PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer

Pratique de base de l'objet PHP-. programmation orientée

<?php
/*
*    通过对象的编程方式，可将实现生活中的一切事物以对象的形式表现出来。便于理解、维护、扩展等；
*    本示例：定义一个“人”类
*    $name : 对象中的成员属性，在此类中表示人的姓名
*    say() : 对象中的成员方法，在此类中表示人说话的方法
*    $this : PHP中的伪变量，表示自身的类
*    __construct() : php中的魔术方法，构造函数，在实例化类时自动执行
*    __destruct() : php中的魔术方法，析构函数，当类调用完成后自动执行
*/
class Human
{
    public $name;
    public $sex;
    public $age;
    public function __construct($name,$sex,$age) 
    {
        $this->name = $name;
        $this->sex = $sex;
        $this->age = $age;
    }
    public function say()
    {
        echo &#39;大家好，我的名字叫&#39;.$this->name.&#39;，今年&#39;.$this->age.&#39;岁，我的性别是&#39;.$this->sex;
    }
    public function __destruct()
    {
        $this->name = null;
        $this->sex = null;
        $this->age = null;
    }
}
//实例化“人”类
$male = new Human("张三","男","20");
//调用“人”类说话的方法
$male->say();

//输出结果：大家好，我的名字叫张三，今年20岁，我的性别是男
?>

2. Pratique avancée de la programmation orientée objet en PHP

Points de connaissances : héritage de classe, réécriture de méthode, contrôle d'accès, mot-clé statique , mot-clé final, accès aux données, interface, polymorphisme, classe abstraite

2.1, héritage de classe : mot-clé extends
Par exemple : un opérateur, un hôte, ils ont des méthodes de comportements humains communes, mais ils ont tous leur posséder différentes spécialités. Par conséquent, vous devez créer une classe parent pour eux et en hériter lors de la programmation ;

<?php
/*
*    创建一个“人”类做为父类，继承的子类都拥有其父类的成员属性、方法
*/
class Human
{
    public $name;
    public function say()
    {
        echo "父类说话的方法，姓名：".$this->name."\n";
    }
    public function eat()
    {
        echo "父类吃饭的方法\n";
    }
}
/*
*    创建一个“运动员”类，继承“人”类
*    extends : 关键字，继承某个类
*/
class Sport extends Human
{
    public $type;    
    public function __construct($name,$type)
    {
        $this->name = $name;    //给父类 $name 属性赋值
        $this->type = $type;    
    }
    public function run()
    {
        $this->say();   //调用父类“说话”的方法
        echo "我在正跑步，我是一员".$this->type."运动员.....\n";
    }
}
/*
*    创建一个“主持人”类，继承“人”类
*    extends : 关键字，继承某个类
*/
class Host extends Human
{
    public $television; 
    public function __construct($name,$television)
    {
        $this->name = $name;    
        $this->television= $television;   
    }
    public function perform()
    {
        $this->eat();   //调用父类“吃饭”的方法
        echo "我在正表演一个节目，我是".$this->television."电视台的一名主持人.....\n";
    }
}

//实例化“运动员”类
$nba = new Sport("乔丹","篮球");
$nba->run();

//实例化“主持人”类
$tv = new Host("张三","北京卫视");
$tv->perform();

//输出结果：
//父类说话的方法，姓名：乔丹 我在正跑步，我是一员篮球运动员..... 
//父类吃饭的方法 我在正表演一个节目，我是北京卫视电视台的一名主持人.....
?>

2.2 Réécriture de méthodes : les sous-classes réécrivent les méthodes de la classe parent

<?php
class Human
{
    public function say()
    {
        echo "父类说话的方法";
    }
}
class Sport extends Human
{
    //重写父类“说话”的方法
    public function say()
    {
        echo "子类说话的方法";
    }
}
$nba = new Sport();
$nba->say();
//输出结果：子类说话的方法
?>

2.3. Contrôle d'accès : mots-clés publics, protégés et privés
public : définit des attributs ou des méthodes de membre publics, qui peuvent être utilisés n'importe où
protected : définit des attributs ou des méthodes de membre protégés, qui ne peuvent être utilisés que par la classe elle-même ou subclasses
private : définit des propriétés ou des méthodes de membres privés, dont l'utilisation est autorisée uniquement par la classe elle-même

<?php
class Human
{
    public $name;
    protected $sex;
    private $age;
    
}
//实例化对象，给公共属性赋值可正常输出结果，外部不能给protected、private受保护的成员属性赋值或使用
$worker = new Human();
$worker->name = "张三";
echo $worker->name;

?>

2.4, mot-clé statique (statique)
1), les attributs statiques sont utilisés pour enregistrer les données publiques de la classe ;
2) Seules les propriétés ou méthodes statiques sont accessibles dans les méthodes statiques, et la pseudo-variable $this ne peut pas être utilisée
3) Les membres statiques sont accessibles et utilisés sans instancier d'objets ; via le mot-clé new ;

<?php
class Human
{
    static $name = "张三";
    static function say()
    {
        echo "我的姓名叫：".self::$name;
    }
}
//外部使用静态成员属性或方法
echo Human::$name;
Human::say();

//输出结果：张三  我的姓名叫：张三
?>

2.5. Mot-clé final : les méthodes membres ne peuvent pas être remplacées ou héritées
Exemple : 1. Pour la méthode "manger" de la classe parent, nous ne voulons pas de sous-classes. de le réécrire ; 2. Pour la classe "Athlètes", nous ne voulons pas qu'elle crée des sous-classes

<?php
class Human
{
    final public function eat()
    {
        echo "父类吃饭的方法，不允许子类重写";
    }
}
final class Sport extends Human
{
    public function eat()
    {
        echo "子类吃饭的方法。此时程序将会报致命错误";
    }
}
//创建一个类继承 Sport 这个类。此时程序也将会报致命错误。因为 Sport 类不允许再创建子类
class Student extends Sport
{
    public $name;
}

//实例化 Sport 类 ，调用 eat() 方法
$nba = new Sport();
$nba->eat();

//实例化 Student 类 ，给 name 属性负值
$obj = new Student();
$obj->name = "张三";

//输出结果：Fatal error: Cannot override final method Human::eat() in ******.php on line 15
//Fatal error: Class Student may not inherit from final class (Sport) in ****.php on line 20
?>

2.6 Accès aux données : $this, self, parents mots-clés
$this : pseudo ; La variable, représentant la classe elle-même, peut accéder aux propriétés et méthodes des membres de cette classe et de la classe parent.
self : accéder aux attributs ou aux méthodes des membres statiques de la classe
parent : accéder aux attributs ou aux méthodes des membres de la classe parent

<?php
class Human
{
    static $name = "张三";
}
class Sport extends Human
{
    static function getParentName()
    {
        echo parent::$name;
    }
    public function get() 
    {
       self::getParentName(); 
    }
}
$obj = new Sport();
$obj->get();
//输出结果：张三
?>

Interface : définir les méthodes de comportement communes des différentes classes, mais il n'est pas implémenté en détail, et des méthodes spécifiques sont implémentées par des sous-classes
Par exemple : les gens peuvent manger, les animaux peuvent aussi manger, et même certaines plantes peuvent manger, mais elles mangent de différentes manières, donc une interface doit être défini à ce moment-là Classe, la méthode spécifique est implémentée par les sous-classes ;
Définir le mot-clé d'interface : interface
Implémenter le mot-clé de méthode d'interface : Implements

<?php
//定义一个接口类，有吃饭的方法，但不具体实现。
interface ICanEat
{
    public function eat($food);
}
class Human implements ICanEat
{
    //eat()方法必须由子类来实现，否则程序将报致命错误
    public function eat($food) 
    {
        echo "I&#39;m eating ".$food;
    }
}
class Animal implements ICanEat
{
    public function eat($food)
    {
        echo "It&#39;s eating ".$food;
    }
}
//实例化一个“人”类
$people = new Human();
$people->eat(&#39;rice&#39;);

//实例化一个“动物”类
$monkey = new Animal();
$monkey->eat(&#39;banana&#39;);

//输出结果：I&#39;m eating rice
// It&#39;s eating banana

?>

2.8 Polymorphisme : Par exemple, l'interface A a. 2 Implémentation de B et C, B et C peuvent avoir différentes implémentations des méthodes définies dans l'interface A. Ce phénomène est appelé polymorphisme
Dans l'exemple ci-dessus, l'interface ICanEat définit une méthode eat() et les humains mangent du riz ; . , le singe mange de la banane. Ils implémentent tous une méthode "eat", mais ils ont des comportements différents lorsqu'ils mangent, ce que l'on appelle le polymorphisme

Classe abstraite : intervient entre l'interface et la définition de la classe, permettant à une partie de la classe de se comporter. La méthode n'est pas implémentée, mais une partie de la méthode qui a la même fonction et ne changera pas est implémentée. Cependant, aucune méthode implémentée n’est autorisée dans les classes d’interface.
Par exemple : les humains et les animaux ont des méthodes pour manger et respirer. Sauf pour manger, les méthodes de respiration sont les mêmes. Dans ce cas, une classe abstraite doit être définie pour la mettre en œuvre.
Définir des mots-clés de classe abstraite : abstract

<?php
//定义一个抽象类，里面有吃饭和呼吸的方法。呼吸方法需要在抽象类中具体实现
abstract class ICanEat
{
    abstract function eat($food);
    public function breath()
    {
        echo &#39;Breath use the air...&#39;;
    }
}
class Human extends ICanEat
{
    public function eat($food)
    {
        echo "I&#39;m eating ".$food;
        $this->breath();
    }
}
//实例化“人”类
$people = new Human();
$people->eat(&#39;rice&#39;);
//输出结果:I&#39;m eating rice Breath use the air...
?>

3. Pratiques particulières de la programmation orientée objet PHP
Quelques méthodes magiques spécifiques au langage PHP :

<?php
class Object
{
    public function __construct()
    {
        echo "当类在被实例化的时候，自动执行该函数";
    }
    public function __toString()
    {
        return "当对象被当作字符串形式输出时，自动执行该函数";
    }
    public function __invoke($value)
    {
        echo "当对象被当作函数调用时，自动执行该函数".$value;
    }
    /*
    *    当对象访问不存在的方法时，自动执行该函数。也称之为“方法重载”
    *    $fun : 方法名称
    *    $param : 传递的参数
    */
    public function __call($fun,$param)
    {
        echo "调用".$fun."方法不存在，传递的参数".implode(&#39;,&#39;,$param);
    }
    /*
    *    当对象访问不存在的静态方法时，自动执行该函数。
    *    $fun : 方法名称
    *    $param : 传递的参数
    */
    static function __callStatic($fun,$param)
    {
        echo "调用".$fun."静态方法不存在，传递的参数".implode(&#39;,&#39;,$param);
    }
    public function __get($key)
    {
        echo "当读取对象中不可访问（未定义）的属性值时，自动调用该函数。".$key."属性不可访问或未定义";
    }
    public function __set($key,$value)
    {
         echo "当给对象中不可访问（未定义）的属性赋值时，自动调用该函数。".$key."属性不可访问或未定义，值".$value;
    }
    public function __isset($key)
    {
        echo "判断对象中的属性不存在时，自动执行该函数。属性：".$key."值未定义";
    }
    public function __unset($key)
    {
        echo "释放对象中的不存在的属性值时，自动执行该函数。属性：".$key."值未定义";
    }
    public function __clone()
    {
        echo "当对象被克隆时，自动执行该函数。";
    }
    public function __destruct()
    {
        echo "当对象执行完成后，自动执行该函数";
    }
}
$obj = new Object();    //实例化对象时，调用__construct()方法
echo $obj;              //将对象以字符串形式输出时，调用__toString()方法
$obj(123);              //当对象以函数形式调用时，执行__invoke()方法
$obj->runTest();        //当调用对象中不存在的方法时，执行__call()方法
$obj::runTest();        //当调用对象中不存在的静态方法时，执行__callStatic()方法
$obj->name;             //当调用对象中不存在的成员属性时，执行__get()方法
$obj->name = "张三";    //当给对象中不存在的成员属性赋值时，执行__set()方法
isset($obj->name) ? 1 : 0;     //判断对象中不存在的成员属性时，执行__isset()方法
unset($obj->name);      //释放对象中的不存在的属性值时，执行__unset()方法
$obj2 = clone $obj;     //当对象被克隆时，执行__clone()方法
                        //对象执行完毕，执行__destruct()方法
?>

Recommandations associées :

Notes orientées objet PHP - 123 Propriétés statiques et méthodes statiques illustrées

Apprenez les trois principales caractéristiques de l'objet PHP -orienté

Exemple détaillé d'implémentation de la fonction PHP de livre d'or orienté objet

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!