Detailed explanation of usage of PHP inheritance class extends

Class inheritance is very important. As a programmer, you basically deal with it every day, but do you really know some things? The following is what you can see from the official website.

A class can use the extends keyword in the declaration to inherit the methods and properties of another class. PHP does not support multiple inheritance, a class can only inherit from one base class.
Inherited methods and properties can be overridden by redeclaring them with the same name. However, if the parent class uses final when defining a method, the method cannot be overridden. Overridden methods or properties can be accessed through parent::.
When overriding a method, the parameters must remain consistent otherwise PHP will issue an E_STRICT level error message . The exception is Constructor, the constructor can use different parameters when overridden.
Everyone must know the basic concepts, but I have never used final and parent:: in the project, which is shameful.
Let’s mainly talk about the uses of these two keywords.

Final keyword

A new keyword added in PHP 5. If a method in the parent class is declared final, the subclass cannot override the method. Likewise if a class is declared final, it cannot be inherited.
It should be noted that: Properties cannot be defined as final, only classes and methods can be defined as final.

Range resolution operator (::)

The range resolution operator or more simply a pair of colons can be used to access static members, class constants, It can also be used to override properties and methods in a class.
The three special keywords self, parent and static are used to access its properties or methods inside the class definition.

When a subclass overrides a method in its parent class, PHP will not call the overridden method in the parent class. Whether the method of the parent class is called depends on the child class. This mechanism also works on constructors and destructors, overloads, and magic methods.

The following is an example of calling a method of a parent class:

<?php
class MyClass
{
    protected function myFunc() {
        echo "MyClass::myFunc()\n";
    }
}
class OtherClass extends MyClass
{
    // 覆盖了父类的定义
    public function myFunc()
    {
        // 但还是可以调用父类中被覆盖的方法
        parent::myFunc();
        echo "OtherClass::myFunc()\n";
    }
}
$class = new OtherClass();
$class->myFunc();
/**
 * 输出结果 ->
 * MyClass::myFunc()
 * OtherClass::myFunc()
 */
?>

When referencing these items outside the class definition, use the class name.
::class Since PHP 5.5, the keyword class can also be used for class name resolution. Using ClassName::class you can get a string containing the fully qualified name of the class ClassName. This is especially useful for classes that use namespaces. These may be topics to be discussed in the future. This concept will be discussed in the future. Now we are still using php5.3.
But to be honest, some keywords are really difficult to use in small projects, but I think it is still necessary to know more about them. Especially when you use some third-party class libraries, you can always learn something when you study its program logic in detail. Although you may forget some things if you don't use them for a long time, after all, they have passed through your mind and will always leave some traces for the rest of your life.
Finally, without further ado, let me share a piece of code for the application of the range parsing operator (::). You can also experience it:

<?php
class cA
{
    /**
     * 直接使用的测试属性的默认值
     */
    protected static $item = &#39;Foo&#39;;

    /**
     * 间接使用的测试属性的默认值
     */
    protected static $other = &#39;cA&#39;;

    public static function method()
    {
        print self::$item."\r\n";
        print self::$other."\r\n";
    }

    public static function setOther($val)
    {
        self::$other = $val;
    }
}
class cB extends cA
{
    /**
     * 重定义测试属性的默认值
     */
    protected static $item = &#39;Bar&#39;;

    public static function setOther($val)
    {
        self::$other = $val;
    }
    /**
     * 不重新声明 method()方法
     */
}
class cC extends cA
{
    /**
     * 重定义测试属性的默认值
     */
    protected static $item = &#39;Tango&#39;;

    public static function method()
    {
        print self::$item."\r\n"; 
        print self::$other."\r\n"; 
    }

    /**
     * 不重新声明 setOther()方法
     */
}
class cD extends cA
{
    /**
     * 重定义测试属性的默认值
     */
    protected static $item = &#39;Foxtrot&#39;;

    /**
     * 不重新声明 任何方法来实现上述过程
     */
}
cB::setOther(&#39;cB&#39;); //  cB::method()!
cB::method(); // cA::method()!
cC::setOther(&#39;cC&#39;); // cA::method()!
cC::method(); // cC::method()!
cD::setOther(&#39;cD&#39;); // cA::method()!
cD::method(); // cA::method()!
/**
 * 输出结果 ->
 * Foo
 * cB
 * Tango
 * cC
 * Foo
 * cD
 */
?>

PHP extends class inheritance code example:

< ?php   
class a{   
public $x;   
public $y;   
function construct($x=0,$y=0){   
$this->x=$x;   
$this->y=$y;   
}   
function getx(){   
return $this->x;   
}   
function gety(){   
return $this->y;   
}   
function destruct(){}   
}   
class a2 extends a{}   
/*extends是一个继承函数*/   
$b2=new a2(10,10);   
echo $b2->getx()."<br>";   
echo $b2->gety();   
?>

The content introduced above is all the implementation steps of PHP extends class inheritance.

The above is the detailed content of Detailed explanation of usage of PHP inheritance class extends. For more information, please follow other related articles on the PHP Chinese website!