Rewriting:

means that when a subclass inherits some methods of the parent class, and the subclass defines the same method internally, the newly defined method will overwrite it. For methods inherited from the parent class, the subclass can only call its internally defined methods.

There are the following requirements:

1. When a parent class and a subclass have a method with exactly the same parameters and names, then the subclass method will override the parent class method. .

The parameters must be consistent to achieve method coverage. When the number of parameters is inconsistent, an error will be reported (this involves the method overloading mentioned above). When the method names are inconsistent, they will not be overwritten, only the newly defined methods of the subclass.

2. When implementing method coverage, the access modifiers can be different, but the access scope of the subclass must be greater than or equal to the access scope of the parent class.

This is the design rule of languages ​​​​such as php. What I understand is that it is easier to access things at a higher level. If you want to access things at a lower level, you must have higher permissions.

Requires parameters and names to be the same. It is not required that the subclass has the same name as the parent class.

requires that the parameters and names are the same. Specifically, the number of parameters is required to be the same as the parent class, but not the parameter names. That is, the name of the parameters passed can be arbitrary, as long as the number passed is the same.

Look at the code:

<?php
class  shao
{
    public function sasa($name){
        echo $name,&#39;狗！<br/>&#39;;
    }
}
class zhen extends shao{
    public function aaa()
    {
        echo &#39;猫<br/>&#39;;
    }
}
$lli = new zhen();
$lli->aaa();
$lli->aaa(&#39;binghh&#39;);
?>

<?php
class fu
{
    public function text(){
        echo &#39;父类&#39;;
    }
    public  function  textt(){
        echo &#39;父亲&#39;;
}
}
class erzi extends fu{
    public function text()
    {
        parent::text();//我要父类的东西
        echo &#39;儿子&#39;;//重写

    }
}
$shili = new fu();
$erzi = new erzi();
$erzi->text();
?>

Overloading:

Overloading is an implementation of polymorphism of the class. Function Overloading means that an identifier is used as multiple function names, and these functions with the same name can be distinguished by the number of parameters or parameter types of the function, and the call does not occur Confused. That is, when called, although the method names are the same, the corresponding functions can be automatically called according to different parameters.

php is not easy to implement.

You can make a method in the class produce multiple effects, and different logic can be executed according to the different parameters passed in.

There are the following requirements:

1. When using overloading, it can only be achieved through the same method name and different parameter forms. Different parameter types can be different parameter types, different parameter numbers, and different parameter orders (parameter types must be different);
2. Overloading cannot be done through access permissions, return types, and thrown exceptions;
3. The exception type and number of methods will not affect overloading;

<?php
class fu
{
    public function text(){
        echo &#39;父类&#39;;
    }
    public  function  textt(){
        echo &#39;父亲&#39;;
    }
}
class erzi extends fu
{

        function test($name)
        {
            //方法重载
            parent::text();//我要父类的东西
            echo "erzi",$name;//重写

        }
    }

$erzi = new fu();
$erzi-> text("123");
?>

Overriding only exists in subclasses and parent classes, and overloading exists in one class.

override is rewriting

overload is overloading

The above is the detailed content of What are php object-oriented rewriting and overloading? What are the requirements for their usage?. For more information, please follow other related articles on the PHP Chinese website!