Explication détaillée de l'utilisation de la classe d'héritage PHP étendue

L'héritage de classe est très important. En tant que programmeur, vous vous en occupez quotidiennement, mais savez-vous vraiment certaines choses ? Voici ce que vous pouvez voir sur le site officiel.

Une classe peut utiliser le mot-clé extends dans la déclaration pour hériter des méthodes et propriétés d'une autre classe. PHP ne prend pas en charge l'héritage multiple, une classe ne peut hériter que d'une seule classe de base.
Les méthodes et propriétés héritées peuvent être remplacées en les redéclarant avec le même nom. Cependant, si la classe parent utilise final lors de la définition d’une méthode, la méthode ne peut pas être remplacée. Les méthodes ou propriétés remplacées sont accessibles via parent ::.
Lors du remplacement d'une méthode, les paramètres doivent être cohérents, sinon PHP émettra un message d'erreur de niveau E_STRICT. L'exception est Constructor, qui peut utiliser différents paramètres en cas de substitution.
Tout le monde doit connaître les concepts de base, mais je n'ai jamais utilisé final et parent :: dans le projet, ce qui est honteux.
Ce qui suit parle principalement des utilisations de ces deux mots-clés.

Mot-clé final

Un nouveau mot-clé en PHP 5. Si une méthode de la classe parent est déclarée finale, la sous-classe ne peut pas remplacer la méthode. De même, si une classe est déclarée finale, elle ne peut pas être héritée.
Il est à noter que les propriétés ne peuvent pas être définies comme finales, seules les classes et méthodes peuvent être définies comme finales.

Opérateur de résolution de portée (::)

Opérateur de résolution de portée ou plus simplement une paire de deux-points, peut être utilisé pour accéder aux membres statiques, aux constantes de classe, il peut également être utilisé pour remplacer les propriétés et méthodes dans une classe.
Les trois mots-clés spéciaux self, parent et static sont utilisés pour accéder à ses propriétés ou méthodes à l'intérieur de la définition de classe.

Lorsqu'une sous-classe substitue une méthode dans sa classe parent, PHP n'appellera pas la méthode substituée dans la classe parent. L'appel de la méthode de la classe parent dépend de la classe enfant. Ce mécanisme fonctionne également pour les constructeurs et les destructeurs, les surcharges et les méthodes magiques.

Voici un exemple d'appel d'une méthode d'une classe parent :

<?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()
 */
?>

Lorsque vous référencez ces éléments en dehors de la définition de la classe, utilisez le nom de la classe.
::class Depuis PHP 5.5, le mot-clé class peut également être utilisé pour la résolution de nom de classe. En utilisant ClassName :: class, vous pouvez obtenir une chaîne contenant le nom complet de la classe ClassName. Ceci est particulièrement utile pour les classes utilisant l'espace de noms. Ce sont peut-être des sujets qui seront discutés à l'avenir. Ce concept sera discuté à l'avenir. Nous utilisons toujours php5.3.
Mais pour être honnête, certains mots-clés sont vraiment difficiles à utiliser dans des petits projets, mais je pense qu'il est quand même nécessaire d'en savoir plus à leur sujet. Surtout lorsque vous utilisez des bibliothèques de classes tierces, vous pouvez toujours apprendre quelque chose en étudiant en détail la logique de son programme. Même si vous pouvez oublier certaines choses si vous ne les utilisez pas pendant une longue période, après tout, elles vous ont traversé l'esprit et laisseront toujours des traces pour le reste de votre vie.
Enfin, sans plus tarder, permettez-moi de partager un morceau de code qui applique l'opérateur d'analyse de plage (::), et vous pouvez également en faire l'expérience :

<?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 étend un exemple de code d'héritage de classe :

< ?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();   
?>

L'introduction ci-dessus présente toutes les étapes d'implémentation de PHP étend l'héritage de classe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!