What are the PHP class method rewriting principles?

PHP class method rewriting principles: 1. Final modified class methods cannot be overridden by subclasses; 2. Whether PHP rewrites parent class methods will only be judged based on whether the method names are consistent; 3. Access during rewriting The level can only be equal to or looser than the parent class, and the access level cannot be increased.

PHP class method rewriting principles:

1. Class methods modified by final cannot be subclassed Rewriting

Final modified class methods cannot be overridden by subclasses. Even if the final private method cannot be inherited by subclasses, it cannot be rewritten in alignment

class FinalMethod
{
    //可继承不可重写
    final public function finalPublic()
    {
        echo "can be inherited, but be overrided";
    }
    //可继承不可重写
    final protected function finalProtected()
    {
        echo "can be inherited, but be overrided";
    }
    //不可继承不可重写 虽然子类继承不到父类的private方法 但同时也会被final限制无法重写
    final private function finalPrivate()
    {
        echo "can not be inherited or be overrided";
    }
    //虽然不可继承 但子类里可重写此方法
    private function private()
    {
        echo "can not be inherited ,but be overrided";
    }
}
class Override extends FinalMethod
{
    //error
    public function finalPublic()
    {
    }
    //error
    protected function finalProtected()
    {
    }
    //error
    private function finalPrivate()
    {
    }
    //correct
    public/protected/private function private()
    {
        //子类继承父类重写父类方法时访问级别只能更加宽松 不可更为严格
    }
}

2. Is PHP Rewriting parent class methods will only be judged based on whether the method names are consistent(After 5.3, the number of parameters of rewritten parent class methods must be consistent)

This does not mean that method parameters have no effect. PHP does not have an overloading mechanism. Therefore, whether it is overridden or not will only be judged by the method name (C/C is considered to be overriding only when the method names are the same and the parameters are also the same. Otherwise, it is overloaded, that is, the state of a polymorphic function is newly defined). When the method names are the same, they are considered to be overriding the parent class method. In 5.2, the parameters can be different. After 5.3, the parameters must be consistent with the parent class method, and all follow the rules of inherited access levels.

class Father
{
    public function index($args_1)
    {
    }
}
class Child extends Father
{
    //5.3以后重写方法必须与父类保持参数个数相同
    public function index($args_1, $args_2)
    {
        //在C/C++中此为重载非重写，因为C/C++具有标准的多态机制，会因参数不同而视为某一方法的另一种态
        //but在php中此依然为重写 但5.3以后此为非法 必须与父类的方法参数个数保持一致
    }
    //5.3以后重写方法必须与父类保持参数个数相同
    private function index($args_1, $args_2)
    {
        //C/C++会因为参数不同于父类方法而视为重载，即新定义了一个函数的态，所以不会受到继承访问权限的限制
        //但php仍然会被视为对父类方法的重写，会受到继承访问权限的升降规则限制
    }
}

3. When overriding, the access level can only be equal to or looser than the parent class and cannot be raised.

The public method of the parent class cannot be overridden as protected by the subclass Or private, the protected method cannot be rewritten as private, it can be looser, not stricter

class Father
{
    public function index()
    {
    }
}
class Child extends Father
{
    protected/private function index()
    {
       //访问权限提升 错误
       //父类为public 则子类重写也只能为public
       //父类为protected 则子类可为public/protected
       //父类为private 则子类public/protected/private皆可
    }
}

In fact, there are many interesting things about the access level inheritance rules

private is in our common sense It cannot be inherited and cannot be obtained by subclasses, but its access level is the highest, so you can write private protected public in the subclass, as if we have redefined a function ourselves. This is especially prominent before version 5.2. Because versions before 5.2 do not need to keep the same number of parameters when inheriting and rewriting parent class methods, but after 5.3, restrictions in this area have been strengthened, and the number of parameters must be the same as the parent class

Note:

When a subclass implements the abstract method of the parent class or the method of a certain class implementing the interface, it is still an inheritance relationship. Still pursuing the access level can only lower the rule that cannot be improved

And

Abstract Methods cannot be declared as private. Abstract-modified methods must be implemented by inheritance, so they can only be public or protected. Method declarations in interfaces must be public. Methods declared in interface must also be implemented by inheritance, and can only be implemented by inheritance. Is public, implements The class of this interface also specifies the method to be rewritten as a public type

Related video recommendation:PHP programming from entry to proficiency

The above is the detailed content of What are the PHP class method rewriting principles?. For more information, please follow other related articles on the PHP Chinese website!