[JAVA] [PHP] Patrons d'héritage, protégés et de référence

Enfant hérité ordinaire → référence parent

Plutôt qu'une référence, la classe enfant a juste $ parentName défini (hérité).

ex1.php

<?php
class ParentClass1
{
    protected string $parentName = "parent\n";
}

class ChildClass1 extends ParentClass1
{
    public function getParentName(): void
    {
        echo $this->parentName;
    }
}

$child = new ChildClass1;
$child->getParentName();

parent

Référence statique Différence entre parent et soi

ex2_1.php

<?php
class ParentClass2
{
    protected static string $parentName = "parent\n";
}

class ChildClass2 extends ParentClass2
{
    public static function getParentName(): void
    {
        // parent::$parentName et soi::$parentName est le même

        echo "test1:" . parent::$parentName;
        echo "test2:" . self::$parentName;   //Hériter de la définition=A parentName comme sa propre propriété

        self::$parentName = "child\n";       //Substitution
        echo "test3:" . parent::$parentName;
        echo "test4:" . self::$parentName;   //Hériter de la définition=A parentName comme sa propre propriété
    }
}

ChildClass2::getParentName();

test1:parent test2:parent test3:child test4:child

ex2_2.php

<?php
class ParentClass3
{
    protected static string $parentName = "parent\n";
}

class ChildClass3 extends ParentClass3
{
    protected static string $parentName = "child\n"; //Différence avec ChildClass2

    public static function getParentName ()
    {
        //Lorsque vous définissez une propriété portant le même nom dans une classe enfant
        // parent::$parentName et soi::$parentName sera différent

        echo "test1:" . parent::$parentName;
        echo "test2:" . self::$parentName;   //A parentName comme sa propre propriété

        self::$parentName = "child2\n";      //Substitution
        echo "test3:" . parent::$parentName;
        echo "test4:" . self::$parentName;   //A parentName comme sa propre propriété
    }
}

ChildClass3::getParentName();

test1:parent test2:child test3:parent test4:child2

Héritage ordinaire: référencement des propriétés enfants du parent (préface)

Identique à ex1.php Un état dans lequel parentFunction () est (hérité) défini dans la classe enfant plutôt qu'une référence.

ex3_1.php

<?php
class ParentClass4
{
    protected string $name = "parent\n";

    protected function parentFunction(): void
    {
        echo $this->name;
    }
}

class ChildClass4 extends ParentClass4
{
    protected string $name = "child\n";

    public function callParentFunction(): void
    {
        $this->parentFunction();
    }
}

$child = new ChildClass4;
$child->callParentFunction();

child

Référence statique sur quoi pointe l'auto et liaison statique retardée

self est la méthode ou la propriété de son propriétaire, static rend les méthodes et propriétés enfants visibles

ex3_2.php

<?php
class ParentClass5
{
    protected static string $name = "parent\n";

    protected static function parentFunction(): void
    {
        echo self::$name;
        echo static::$name; //Liaison statique retardée
    }
}

class ChildClass5 extends ParentClass5
{
    protected static string $name = "child\n";

    public static function callParentFunction(): void
    {
        // parent::parentFunction et self::Le statut de parentFunction
        // ex2_1.php, ex2_2.Voir php
        self::parentFunction();
    }
}

ChildClass5::callParentFunction();

parent child

ex3_3.php

<?php
class ParentClass6
{
    protected static string $name = "parent\n";

    protected static function parentFunction(): void
    {
        echo self::$name;
        echo static::$name; //Liaison statique retardée
    }
}

class ChildClass6 extends ParentClass6
{
    protected static string $name = "child\n";

    protected static function parentFunction(): void // ex3_2.Différence de php
    {
        echo self::$name;
        echo static::$name;
    }

    public static function callParentFunction(): void
    {
        // parent::parentFunction et self::Le statut de parentFunction
        // ex2_1.php, ex2_2.Voir php
        self::parentFunction();
    }
}

ChildClass6::callParentFunction();

child child

Que les parents peuvent utiliser la classe enfant protégée

Même s'il dit qu'il peut être référencé l'un à l'autre, il y a peu d'utilisations, donc vous pouvez ne pas voir beaucoup de détails Il semble qu'il ne puisse pas être utilisé avec le motif \ # Factory, mais il existe d'autres moyens de le faire ...

Erreur commune

\ # Parce que c'est PHP

ex4_0.php

<?php
class ParentClass7
{
    public function getChildName(): void
    {
        echo $this->name;
    }
}

class ChildClass7 extends ParentClass7
{
    protected string $name = "child\n";
}

$parent = new ParentClass7;
$parent->getChildName();       // ""

$parent->name = "parent_name";
var_dump($parent);             //Nouvelle propriété publique ajoutée à la classe parent
$parent->getChildName();       //Cela fonctionne, mais la définition de la classe enfant n'est pas pertinente

object(ParentClass7)#1 (1) {     ["name"]=>     string(11) "parent_name" } parent_name

Si vous regardez l'instance, vous pouvez lire protégé s'il y a des extensions, et vous ne pouvez pas le lire s'il n'y a pas de relation directe.

ex4_1_1.php

<?php
class ParentClass8
{
    public function getChildName(): void
    {
        $child = new ChildClass8; //Une instance de cette ChildClass($child)Et moi-même($parent)Même s'il ne semble pas avoir de relation directe avec
        echo $child->name;        //Par définition, l'enfant protégé peut être référencé s'il s'agit d'un parent et d'un enfant
    }

    public function callChildFunction(): void
    {
        ChildClass8::childFunction(); //Même si ce n'est pas une instance.
    }
}

class ChildClass8 extends ParentClass8
{
    protected string $name = "child\n";

    protected static function childFunction(): void
    {
        echo "child_function\n";
    }
}

$parent = new ParentClass8;
$parent->getChildName();
$parent->callChildFunction();

child child_function

ex4_1_2.php

<?php
class ParentClass9
{
    public function getChildName(ChildClass9 $child): void
    {
        echo $child->name; //Par définition, parent et enfant peuvent faire référence à un enfant protégé
    }

    public function callChildFunction(ChildClass9 $child): void
    {
        $child->childFunction();
    }
}

class ChildClass9 extends ParentClass9
{
    protected string $name = "child\n";

    protected function childFunction(): void
    {
        echo "child_function\n";
    }
}

$parent = new ParentClass9;
$child = new ChildClass9;
$parent->getChildName($child); //Une instance de cette ChildClass($child)Et moi-même($parent)Même s'il ne semble pas y avoir de relation directe avec
$parent->callChildFunction($child);

child child_function

Bien sûr, vous ne pouvez pas lire sans étendre

ex4_2.php

<?php
class ParentClass10
{
    public static function getChildName(): void
    {
        $child = new ChildClass10;
        echo $child->name;
    }

    public static function callChildFunction(): void
    {
        ChildClass10::childFunction();
    }
}

class ChildClass10 /* extends ParentClass10 */
{
    protected string $name = "child\n";

    protected static function childFunction(): void
    {
        echo "child_function\n";
    }
}

ParentClass10::getChildName();

Error: Cannot access protected property ChildClass10::$name

De côté

Private de la même classe peut être lu même si les instances sont séparées

ex5.php

<?php
class Test
{
    private string $name = "";

    public function __construct(string $name = "")
    {
        $this->name = $name;
    }

    public function getName(Test $instance): void
    {
        echo $instance->name;
    }
}

$instanceA = new Test("A");
$instanceB = new Test("B");

$instanceA->getName($instanceB);

B

C'est presque la même chose dans d'autres langues, alors essayez-le