PHP objektorientiert – Beispielcode, der die Überladung detailliert beschreibt

Überladen

Das „Überladen“ in PHP unterscheidet sich von den meisten anderen objektorientierten Sprachen, außer dass sie alle dasselbe Substantiv verwenden. Traditionelles „Überladen“ wird verwendet, um mehrere Klassenmethoden mit demselben Namen bereitzustellen, aber jede Methode verfügt über unterschiedliche Parametertypen und -nummern. Das von PHP bereitgestellte „Überladen“ bezieht sich auf das dynamische „Erstellen“ von Klasseneigenschaften und -methoden. Die überladene Methode wird aufgerufen, wenn ein Klassenattribut oder eine Klassenmethode aufgerufen wird, die in der aktuellen Umgebung undefiniert oder unsichtbar ist. Dies wird durch magische Methoden erreicht.
Im Allgemeinen entspricht die Definition aller Mitgliedsattribute in einer Klasse als privat eher einer realistischen Logik und kann die Mitglieder in der Klasse besser schützen. Lese- und Zuweisungsoperationen zu Mitgliedseigenschaften kommen jedoch sehr häufig vor, und es ist sehr, sehr mühsam, für jede private Eigenschaft in der Klasse eine öffentliche Methode zu definieren, die außerhalb des Objekts abgerufen und zugewiesen werden kann. Daher sind in Versionen nach PHP 5.1.0 zwei Methoden „get()“ und „set()“ vordefiniert, die dazu dienen, alle verwendeten privaten Attribute abzurufen und ihnen Werte zuzuweisen sowie zu prüfen, ob die privaten Attribute vorhanden sind . Die Methode „isset()“ und die Methode „unset()“ werden zum Löschen privater Eigenschaften im Objekt verwendet.
Laienhaft ausgedrückt bezieht sich die Bedeutung von Überladung in PHP auf einige der „Verarbeitungsmechanismen“, wenn ein Objekt oder eine Klasse ihre undefinierten oder unsichtbaren Eigenschaften und Methoden verwendet.

Attributüberladung

Bei Verwendung eines Attributs, das in einem Objekt nicht vorhanden ist, gibt es in dieser Klasse voreingestellte Gegenmaßnahmen (Verarbeitungsmechanismus). ).
　Attribute sind im Wesentlichen Variablen, die nur 4 Operationen haben:

Wert:

Wann Wenn eine Eigenschaft Wenn ein Objekt nicht existiert (undefiniert oder unsichtbar) „abgerufen“ wird, wird die Methode automatisch aufgerufen: Bei der GET()-Methode wird die Groß-/Kleinschreibung nicht beachtet.

Zuweisung:

Wenn ein Objekt nicht existiert (undefiniert oder unsichtbar), werden Eigenschaften „zugewiesen“, es wird automatisch aufgerufen. Methode: SET ()

Urteil (isset):

Wenn eine Eigenschaft eines Objekts nicht existiert (undefiniert oder unsichtbar) Beim Erstellen von isset() Urteil, die Methode wird automatisch aufgerufen: isset()

Zerstörung (nicht gesetzt):

Wenn ein Objekt nicht mehr vorhanden ist (undefiniertes oder unsichtbares) Attribut wird durch unset() beurteilt, die Methode wird automatisch aufgerufen: unset()

Die oben genannten vier Methoden werden als magische Methoden bezeichnet.

Magische Methode

GET($property name):

Eine Methode, die automatisch aufgerufen wird, wenn ein Wert für ein nicht vorhandenes Attribut eines Objekts abgerufen wird. Diese Methode kann einen formalen Parameter annehmen, der den Namen des nicht vorhandenen Attributs angibt, das abgerufen werden soll ( Zeichenkette). ), können Sie diese Methode verwenden, um eine spezielle Verarbeitung in unerwarteten Situationen durchzuführen.

Zum Beispiel:

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

Überlastung von PHP. Verwenden Sie die Methode get(), um den oben genannten Fehler „anständig zu behandeln“.

<?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，但经过"处理"?>

Hier ist ein Beispiel für eine Operation zum Erhalten der genutzten Privatgrundstücke.

Beispiel:

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

Das laufende Ergebnis ist:

name=yeoman, sex=男, age=23

SET ($attribute name, value):

Beim „Zuweisen“ eines nicht vorhandenen Attributs wird diese interne magische Methode automatisch aufgerufen. Sie verfügt über zwei formale Parameter, die jeweils die „Zuweisung“ des nicht vorhandenen Attributs darstellen Name“ und „Attributwert“.
Diese Methode kann in Kombination mit der _GET-Methode häufig die von uns definierte Klasse erweiterbarer machen. Das heißt: Die Attribute einer Klasse oder eines Objekts können bequemer und freier sein.

Beispiel:

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

Das laufende Ergebnis ist:

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

ISSET ($attribute name):

Wenn isset() anhand einer Eigenschaft beurteilt wird, die in einem Objekt nicht vorhanden ist, wird die interne Methode automatisch aufgerufen: isset();

Verwendung:

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

Beispiel:

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

Laufergebnisse:

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

boolean trueboolean false

UNSET($property name)

Wann ein Objekt ist nicht Wenn ein vorhandenes Attribut durch unset() zerstört wird, wird die interne Methode automatisch aufgerufen: 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;?>

Das laufende Ergebnis ist:

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

---

Deklarieren Sie im folgenden Beispiel eine Person-Klasse und setzen Sie alle Mitgliedseigenschaften auf privat. Fügen Sie der Klasse zwei benutzerdefinierte Methoden „isset()“ und „unset()“ hinzu. Diese beiden Methoden werden automatisch aufgerufen, wenn die Funktionen „isset()“ und „unset()“ außerhalb der Klasse verwendet werden. Der Code lautet wie folgt:

<?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，性别：，年龄：
?>

Laufergebnisse:

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()这个魔术方法。和上面的处理类似。

Das obige ist der detaillierte Inhalt vonPHP objektorientiert – Beispielcode, der die Überladung detailliert beschreibt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!