PHP object-oriented - detailed explanation of object cloning clone and magic method __clone()

1.ObjectClone

PHP4Object-oriented A big shortcoming of the function is that Objects are treated as another data type, which makes many common OOP methods unusable, such as Design Patterns. These methods rely on passing the object as a reference to other class methods, rather than as a value, which is PHP's default practice. Fortunately, PHP5 solves this problem and now all objects are treated as references by default. However, since all objects are treated as references rather than values, it is now more difficult to copy objects. If you try to copy a referenced object, this will only point to the address of the original object. To solve the copying problem, PHP provides an explicit method of cloning a clone (keyword, not a method) object.

You can clone the object by adding the clone keyword in front of the object, as follows:

destinationObject = clone targetObject;

Clone the object:

<?phpclass Person{
    var $name;    
    var $sex;    
    var $age;    
    function construct($name, $sex, $age){
        $this->name = $name;        
        $this->sex = $sex;        
        $this->age = $age;   
    }    function say(){
        echo "我的名字：" . $this->name . "，性别：" . $this->sex . "，年龄：" .$this->age . "<br />"; 
    }
}$person1 = new Person("张三三", "男", 23);
$person2 = clone $person1;   //使用clone关键字克隆/复制对象，创建一个对象的副本
$person3 = $person1;   //这不是复制对象，而是为对象多复制出一个访问该对象的引用
$person1->say();   //调用原对象中的说话方式，打印原对象中的全部属性值
$person2->say();   //调用副本对象中的说话方式，打印克隆对象中的全部属性值
$person3->say();   //调用原对象中的说话方式，打印原对象中的全部属性值?>

2.Magic method clone()

In the above program, a total of two objects are created, one of which is a copy cloned through the clone keyword. Two objects can be completely independent, but the values ​​of their members and properties are exactly the same. If you need to reassign initial values ​​to member properties of the cloned copy object during cloning, you can declare a magic method "clone()" in the class. This method is automatically called when the object is cloned, so you can reinitialize the cloned copy through this method. The clone() method does not require any parameters. Rewrite the code in the above example, add the magic method clone() to the class, and reinitialize the member properties in the copy object.

<?phpclass Person{
    var $name;    
    var $sex;    
    var $age;    
    function construct($name, $sex, $age){
        $this->name = $name;        
        $this->sex = $sex;        
        $this->age = $age;  
    }    function say(){
        echo "我的名字：" . $this->name . "，性别：" . $this->sex . "，年龄：" .$this->age . "<br />";    
    }    function clone(){
        $this->name = "李四四";   //为副本对象中的name属性重新赋值
        $this->age = 10;   //为副本对象中的age属性重新赋值
    }
}$person1 = new Person("张三三", "男", 23);
$person2 = clone $person1;  //创建一个对象的副本，并自动调用类中的clone()方法
$person1->say();   //调用原对象中的说话方式，打印原对象中的全部属性值
$person2->say();   //调用副本对象中的说话方式，打印克隆对象中的全部属性值?>

Run result:

我的名字：张三三，性别：男，年龄：23
我的名字：李四四，性别：男，年龄：10

3. Enhancement of singleton class: prohibit cloning

For objects of a class , if you use "cloneoperator", a new object that is exactly the same as the current object will be copied, and the magic method of this class will be automatically called at this time: clone() (as long as the There is this method in the class).
If you want to implement a singleton class, you should "disable cloning" of the object of this singleton class. In PHP, in order to prevent the cloning of the singleton class object from breaking the above implementation form of the singleton class, an empty private (private modified) clone is usually provided for it ()method.
　
First let’s look at the effect of "no cloning is prohibited" :

<?php
class SingetonBasic {
    private static $instance;  
    //静态变量要私有化，防止类外修改

    private function construct() {    
    //构造函数私有化，类外不能直接新建对象}
    //
    private function clone() {} 
    //在clone()前用private修饰，用来禁止克隆
    public static function getInstance() {  //公共的静态方法,
    public——外部的接口，static——不使用对象而是通过类名访问
    if (!(self::$instance instanceof self)) { //私有静态变量$instance为空
        self::$instance = new self();  //新建为自身的对象，并赋值给私有变量$instance
    }    return self::$instance;	//返回私有变量$instance}

}$a = SingetonBasic::getInstance();$b = SingetonBasic::getInstance();
var_dump($a === $b);   //结果为：boolean true     a和b指向的是同一个对象$c = clone $a;
var_dump($a === $c); //结果为：boolean false      a和c指向的不是同一个对象?>

The running result is

boolean trueboolean false

We "prohibit cloning", that is Remove the

comment

from the

private function clone() {}   //在clone()前用private修饰，用来禁止克隆

line in the above code.

The running result is

boolean trueFatal error: Call to private SingetonBasic::clone()

That is, when cloning, clone() is automatically called, but the method is privately modified and cannot be called directly from outside the class, resulting in an error.

The above is the detailed content of PHP object-oriented - detailed explanation of object cloning clone and magic method __clone(). For more information, please follow other related articles on the PHP Chinese website!