Usage analysis of initialize() and constructor construct() in ThinkPHP

This article mainly introduces the usage of _initialize() and class constructor _construct() in ThinkPHP. It analyzes the method of constructing subclasses during initialization of classes in ThinkPHP in the form of examples. It is an object-oriented program using ThinkPHP. Friends who need it can refer to the more important concepts in design

This article analyzes __initialize() and the class constructor __construct() in ThinkPHP through examples. Share it with everyone for your reference. The specific analysis is as follows:

__construct in thinkphp cannot be used casually, because your module class inherits the superior class, and the superior class is defined;

1. __initialize() is not Functions in the php class, the constructor of the php class is only __construct().

2. Class initialization: If the subclass has its own constructor (__construct()), it calls its own for initialization. If not, call the constructor of the parent class to perform its own initialization.

3. When both the subclass and the parent class have __construct() functions, if you want to call the parent class's __constrcut() at the same time when initializing the subclass, you can use parent in the subclass. ::__construct().

If we write two classes, as follows:

class Action{  
    public function __construct()  
    {  
        echo 'hello Action';  
    }  
}  
class IndexAction extends Action{  
    public function __construct()  
    {  
        echo 'hello IndexAction';  
    }  
}  
$test = new IndexAction;  
//output --- hello IndexAction

Obviously when initializing the subclass IndexAction, it will call its own constructor, so the output is 'hello IndexAction' , but modify the subclass to:

class IndexAction extends Action{  
    public function __initialize()  
    {  
        echo 'hello IndexAction';  
    }  
}

Then the output is 'hello Action', because the subclass IndexAction does not have its own constructor, if I want to call the parent at the same time when initializing the subclass What about the constructor of the class?

class IndexAction extends Action{  
    public function __construct()  
    {  
        parent::__construct();  
        echo 'hello IndexAction';  
    }  
}

In this way, two sentences can be output at the same time. Of course, another way is to call the method of the subclass in the parent class.

class Action{  
    public function __construct()  
    {  
        if(method_exists($this,'hello'))  
        {  
            $this -> hello();  
        }  
        echo 'hello Action';  
    }  
}  
class IndexAction extends Action{  
    public function hello()  
    {  
        echo 'hello IndexAction';  
    }  
}

In this way, you can also output the two sentences at the same time. The two sentences are output at the same time, and the method hello() in the subclass here is similar to __initialize() in ThinkPHP.

So, the appearance of __initialize() in ThinkPHP is only to facilitate programmers to avoid frequent use of parent::__construct() when writing subclasses, and at the same time correctly call the constructor of the parent class in the framework. Therefore, when we initialize a subclass in ThnikPHP, we must use __initialize() instead of __construct(). Of course, you can also modify the __initialize() function to your favorite function name by modifying the framework.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

move_uploaded_file() function in PHP

##ThinkPHP class constructor _construct() The difference with _initialize()

The above is the detailed content of Usage analysis of initialize() and constructor construct() in ThinkPHP. For more information, please follow other related articles on the PHP Chinese website!