PHP orienté objet - exemple de code détaillant la surcharge

Surcharge

La "surcharge" en PHP est différente de la plupart des autres langages orientés objet, sauf qu'ils utilisent tous le même nom. La « surcharge » traditionnelle est utilisée pour fournir plusieurs méthodes de classe portant le même nom, mais chaque méthode a des types et des numéros de paramètres différents. La « surcharge » fournie par PHP fait référence à la « création » dynamique de propriétés et de méthodes de classe. La méthode surchargée sera appelée lors de l'appel d'un attribut de classe ou d'une méthode non définie ou invisible dans l'environnement actuel. Ceci est réalisé grâce à des méthodes magiques.
De manière générale, définir tous les attributs des membres d'une classe comme privés est plus conforme à une logique réaliste et peut mieux protéger les membres de la classe. Cependant, les opérations de lecture et d'affectation des propriétés des membres sont très fréquentes, et il est très, très ennuyeux de définir pour chaque propriété privée d'une classe une méthode publique qui peut être obtenue et assignée en dehors de l'objet. Par conséquent, dans les versions postérieures à PHP 5.1.0, deux méthodes "get()" et "set()" sont prédéfinies, qui sont utilisées pour obtenir et attribuer des valeurs à tous les attributs privés utilisés, et pour vérifier si les attributs privés existent. . La méthode "isset()" et la méthode "unset()" utilisées pour supprimer les propriétés privées de l'objet.
En termes simples, la signification de la surcharge en PHP fait référence à certains des « mécanismes de traitement » lorsqu'un objet ou une classe utilise ses propriétés et méthodes non définies ou invisibles.

Surcharge d'attribut

Lors de l'utilisation d'un attribut qui n'existe pas dans un objet, il existe des contre-mesures prédéfinies dans cette classe (mécanisme de traitement ).
　Les attributs sont essentiellement des variables, qui n'ont que 4 opérations :

Valeur :

Quand Quand une propriété d'un objet n'existe pas (indéfini ou invisible) est "récupéré", la méthode est automatiquement appelée : la méthode GET() n'est pas sensible à la casse.

Affectation :

Lorsqu'un objet n'existe pas (non défini ou invisible), les propriétés sont "attribuées", il sera automatiquement Appelé la méthode : SET ()

Jugement (isset) :

Lorsqu'une propriété d'un objet n'existe pas (indéfinie ou invisible) Lors de la création d'isset() jugement, la méthode sera appelée automatiquement : isset()

Destruction (unset) :

Lorsqu'un objet n'est plus Lorsqu'un objet existant (indéfini ou invisible) est jugé par unset(), la méthode sera automatiquement appelée : unset()

Les quatre méthodes ci-dessus sont appelées méthodes magiques.

Méthode magique

GET($nom de la propriété) :

Une méthode qui sera automatiquement appelée lors de "l'obtention d'une valeur" pour un attribut inexistant d'un objet. Cette méthode peut prendre un paramètre formel, indiquant le nom de l'attribut inexistant à récupérer (chaîne de caractères ). ), vous pouvez utiliser cette méthode pour effectuer un traitement spécial sur des situations inattendues.

Par exemple :

<?phpclass A{
    public  $p1 = 1;
}$a1 = new A();echo $a1->p1;  //1echo $a1->p2;	//未定义$p2，会报错, Notice: Undefined property: A::$p2?>

Surcharge de php, utilisez la méthode get() pour "gérer gracieusement" l'erreur ci-dessus.

<?php<?phpclass A{
    public  $p1 = 1;    
    //private $p2 = 1;  
    //这里将属性私有化，其实和未定义一样，对外部来说都相当于不存在

    function get($prop_name){

        /*
        //比如可以这样处理
        echo "<br />{$prop_name}属性还未定义（不存在）！";
        return "";  //也可以返回0，或false等
        */

        //还可以这样处理
        trigger_error("发生错误：属性不存在！", E_USER_ERROR);        
        die();
    }
}$a1 = new A();echo $a1->p1;  //1echo $a1->p2;	//未定义$p2，但经过"处理"?>

Voici un exemple d'opération pour obtenir les propriétés privées utilisées.

Exemple :

<?phpclass Person{
    public $name;  
    public $sex;    
    private $age;  //年龄私有化，类外不能直接访问这个属性    

    function construct($name=&#39;&#39;, $sex=&#39;&#39;, $age){
        $this->name = $name;        
        $this->sex = $sex;        
        $this->age = $age;   
    }    private function get($propertyName){ //这里要用private修饰，防止类外部调用
        if($propertyName == &#39;age&#39;){            
        return $this->age;
        }
    }
}$p = new Person(&#39;yeoman&#39;, &#39;男&#39;,23);
$v1 = $p->name;$v2 = $p->sex;$v3 = $p->age;    
//自动调用了get()方法获取私有属性age（函数定义里面返回）
echo "name=$v1, sex=$v2, age=$v3";?>

Le résultat en cours d'exécution est :

name=yeoman, sex=男, age=23

SET ($nom de l'attribut, valeur) :

Lors de "l'attribution" d'un attribut inexistant d'un objet, cette méthode magique interne sera automatiquement appelée ; elle possède 2 paramètres formels, représentant respectivement "l'affectation" de l'attribut inexistant. nom" et "Valeur de l'attribut".
Cette méthode, combinée à la méthode _GET, peut souvent rendre la classe que nous définissons plus extensible. Autrement dit : les attributs d'une classe ou d'un objet peuvent être plus pratiques et gratuits.

Exemple :

<?phpclass A{
    //定义一个属性，
    protected $prop_list = array();    
    //初始为空数组

    //这个方法会在A的对象使用一个不存在的属性进行赋值时调用
    function set($p,$v){
        //echo "使用不存在的属性！";
        $this->prop_list[$p] = $v;     
    }    function get($p){
        return $this->prop_list[$p];    
    }
}$a1 = new A();$a1->p1 = 1;   
//不存在的属性名赋值，此时会调用_set()，并传过去"p1"和1$a1->p2 = 2;$a1->ac = &#39;avc&#39;;
echo "<br />输出这些“不存在的属性”的值：";
echo "<br />a1->p1:" . $a1->p1;    
//不存在的属性名取值，此时会调用_get()，并传过去"p1"echo "<br />a1->p2:" . $a1->p2;echo "<br />a1->ac:" . $a1->ac;?>

Le résultat en cours d'exécution est :

输出这些“不存在的属性”的值：a1->p1:1a1->p2:2a1->ac:avc

ISSET ($nom de l'attribut) :

Lorsque isset() est jugé sur une propriété qui n'existe pas dans un objet, la méthode interne sera automatiquement appelée : isset();

Utilisation :

$v1 = isset($对象->不存在的属性);    //此时会调用这个对象所属类中的魔术方法：isset()

Exemple :

<?phpclass A{
    //定义一个属性，
    protected $prop_list = array();    //初始为空数组

    //这个方法会在A的对象使用一个不存在的属性进行赋值时调用
    function set($p,$v){
        //echo "使用不存在的属性！";
        $this->prop_list[$p] = $v;     
    }    function get($p){
        if($this->prop_list[$p]){            return $this->prop_list[$p];
        }else{            return "该属性不存在！";
        }
    }    function isset($prop){   //isset()是自定义的方法, isset()是系统函数
        $re = isset($this->prop_list[$prop]);        return $re;
    }
}
$a1 = new A();
$a1->p1 = 1;//不存在的属性名赋值，此时会调用_set()，并传过去"p1"和1
$a1->p2 = 2;
$a1->ac = &#39;avc&#39;;
echo "<br />输出这些“不存在的属性”的值";
echo "<br />a1->p1:" . $a1->p1;//不存在的属性名取值，此时会调用_get()，并传过去"p1"
echo "<br />a1->p2:" . $a1->p2;
echo "<br />a1->ac:" . $a1->ac;
//下面演示isset判断不存在的属性
$v1 = isset($a1->p1);  //存在
$v2 = isset($a1->ppp1);    //不存在
var_dump($v1);echo "<br />";
var_dump($v2);?>

Résultats d'exécution :

输出这些“不存在的属性”的值
a1->p1:1a1->p2:2a1->ac:avc

boolean trueboolean false

UNSET($property name)

Quand un objet ne l'est pas Lorsqu'un attribut existant est détruit par unset(), la méthode interne sera automatiquement appelée : unset();

<?phpclass A{
    //定义一个属性，
    protected $prop_list = array();    
    //初始为空数组

    //这个方法会在A的对象使用一个不存在的属性进行赋值时调用
    function set($p,$v){
        //echo "使用不存在的属性！";
        $this->prop_list[$p] = $v;     
    }    function get($p){
        if($this->prop_list[$p]){            
        return $this->prop_list[$p];
        }else{            
        return "该属性不存在！";
        }
    }    function unset($prop){
        unset($this->prop_list[$prop]); 
    }
}$a1 = new A();
$a1->p1 = 1;//不存在的属性名赋值，此时会调用_set()，并传过去"p1"和1
echo "<br />a1->p1:" . $a1->p1;//不存在的属性名取值，此时会调用_get()，并传过去"p1"//下面演示unset销毁一个不存在的属性
unset($a1->p1);
echo "<br />a1->p1:" . $a1->p1;?>

Le résultat en cours d'exécution est :

a1->p1:1a1->p1:该属性不存在！

---

Dans l'exemple suivant, déclarez une classe Person et définissez toutes les propriétés des membres sur private. Ajoutez deux méthodes personnalisées "isset()" et "unset()" à la classe. Ces deux méthodes sont automatiquement appelées lorsque les fonctions "isset()" et "unset()" sont utilisées en dehors de la classe. Le code est le suivant :

<?php
class Person{
    private $name; //此属性被封住
    private $sex;
    private $age;

    function __construct($name=&#39;&#39;, $sex=&#39;男&#39;, $age){
        $this->name = $name;
        $this->sex = $sex;
        $this->age = $age;  
    }

    private function __isset($propertyName){   //需要一个参数，是测定的私有属性的名称
        if($propertyName == &#39;name&#39;){
            return false;   //返回假，不允许在类外部测定name属性   
        }
        return isset($this->$propertyName);   //这里propertyName要加$符,因为这是参数，不是属性
    }                       

    private function __unset($propertyName){
        if($propertyName == &#39;name&#39;)
            return; //退出方法，不允许删除对象中的name属性
        unset($this->$propertyName);  //这里propertyName要加$符
    }

    public function say(){
        echo "名字：" . $this->name . "，性别：" . $this->sex . "，年龄：" . $this->age . "<br />"; 
    }

}

$person = new Person("yeoman", "男", 23);

var_dump(isset($person->name));    //输出bool(false)，不允许测定name属性
var_dump(isset($person->sex)); //输出bool(true)，存在sex私有属性
var_dump(isset($person->age)); //输出bool(true)，存在age私有属性
var_dump(isset($person->id));  //输出bool(false)，测定对象中不存在id属性

unset($person->name);  //删除私有属性name，但在 __unset()中不允许删除
unset($person->sex);   //删除对象中的私有属性sex，删除成功
unset($person->age);

$person->say();    //对象中的sex和age属性被删除，输出：名字：yeoman，性别：，年龄：
?>

Résultats en cours d'exécution :

boolean falseboolean trueboolean trueboolean false名字：yeoman，性别：，年龄：

方法重载

　　当对一个对象不存在的实例方法进行“调用”时，会自动调用类中的call()这个魔术方法；
　　当对一个类不存在的静态方法进行“调用”时，会自动调用类中的callstatic()这个魔术方法。

例子：直接调用不存在的方法

<?phpini_set(&#39;display_errors&#39;,1);class A{}$a = new A();$a->f1();  //不存在的方法?>

　　会报错，报错内容为：

Fatal error: Uncaught Error: Call to undefined method A::f1()

　　对上面报错作“优雅处理”：

<?phpclass A{
    //当对这个类的对象不存在的实力方法进行调用时，会自动调用本方法
    //这个方法必须带2个形参：
    //$methodName:表示要调用的不存在的方法名；
    //$argument:表示要调用该不存在的方法时，所使用的实参数据，是一个数组。
    function call($methodName, $argument){
        //echo "call被调用了！";
        echo $methodName . "()方法不存在！";
    }
}$a = new A();$a->f1();  //不存在的方法,但经过处理?>

　　运行结果为：

f1()方法不存在！

　　当对一个类不存在的静态方法进行“调用”时，会自动调用类中的callstatic()这个魔术方法。和上面的处理类似。

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!