[JAVA] [PHP] Vererbungs-, Schutz- und Referenzmuster

Gewöhnliche geerbte Kind → Elternreferenz

Anstelle einer Referenz hat die untergeordnete Klasse nur $ parentName definiert (geerbt).

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

Statische Referenz Unterschied zwischen Eltern und Selbst

ex2_1.php

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

class ChildClass2 extends ParentClass2
{
    public static function getParentName(): void
    {
        // parent::$Elternname und Selbst::$parentName ist der gleiche

        echo "test1:" . parent::$parentName;
        echo "test2:" . self::$parentName;   //Definition erben=Hat parentName als eigene Eigenschaft

        self::$parentName = "child\n";       //Auswechslung
        echo "test3:" . parent::$parentName;
        echo "test4:" . self::$parentName;   //Definition erben=Hat parentName als eigene Eigenschaft
    }
}

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"; //Unterschied zu ChildClass2

    public static function getParentName ()
    {
        //Wenn Sie eine Eigenschaft mit demselben Namen in einer untergeordneten Klasse definieren
        // parent::$Elternname und Selbst::$parentName wird anders sein

        echo "test1:" . parent::$parentName;
        echo "test2:" . self::$parentName;   //Hat parentName als eigene Eigenschaft

        self::$parentName = "child2\n";      //Auswechslung
        echo "test3:" . parent::$parentName;
        echo "test4:" . self::$parentName;   //Hat parentName als eigene Eigenschaft
    }
}

ChildClass3::getParentName();

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

Gewöhnliche Vererbung: Verweisen auf untergeordnete Eigenschaften vom übergeordneten Element (Vorwort)

Gleich wie ex1.php Ein Zustand, in dem parentFunction () in der untergeordneten Klasse und nicht in einer Referenz definiert (vererbt) ist.

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

Statische Referenz Was selbst auf statische Bindung hinweist und diese verzögert

Selbst ist die Methode oder das Eigentum seines Besitzers, static macht untergeordnete Methoden und Eigenschaften sichtbar

ex3_2.php

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

    protected static function parentFunction(): void
    {
        echo self::$name;
        echo static::$name; //Verzögerte statische Bindung
    }
}

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

    public static function callParentFunction(): void
    {
        // parent::parentFunction und self::Der Status von parentFunction
        // ex2_1.php, ex2_2.Siehe 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; //Verzögerte statische Bindung
    }
}

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

    protected static function parentFunction(): void // ex3_2.Unterschied zu php
    {
        echo self::$name;
        echo static::$name;
    }

    public static function callParentFunction(): void
    {
        // parent::parentFunction und self::Der Status von parentFunction
        // ex2_1.php, ex2_2.Siehe PHP
        self::parentFunction();
    }
}

ChildClass6::callParentFunction();

child child

Dass Eltern die geschützte Kinderklasse nutzen können

Selbst wenn geschrieben steht, dass es aufeinander bezogen werden kann, gibt es nur wenige Verwendungszwecke, sodass Sie möglicherweise nicht viele Details sehen Es scheint, dass es nicht mit dem \ # Factory-Muster verwendet werden kann, aber es gibt andere Möglichkeiten, dies zu tun ...

Häufige Missverständnisse

\ # Weil es PHP ist

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);             //Neue öffentliche Eigenschaft zur übergeordneten Klasse hinzugefügt
$parent->getChildName();       //Es funktioniert, aber die Definition der untergeordneten Klasse ist irrelevant

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

Wenn Sie sich die Instanz ansehen, können Sie geschützt lesen, wenn es Erweiterungen gibt, und Sie können sie nicht lesen, wenn keine direkte Beziehung besteht.

ex4_1_1.php

<?php
class ParentClass8
{
    public function getChildName(): void
    {
        $child = new ChildClass8; //Eine Instanz dieser ChildClass($child)Und ich selber($parent)Auch wenn es keine direkte Beziehung zu zu haben scheint
        echo $child->name;        //Per Definition kann auf untergeschützte Kinder verwiesen werden, wenn es sich um Eltern und Kinder handelt
    }

    public function callChildFunction(): void
    {
        ChildClass8::childFunction(); //Auch wenn es keine Instanz ist.
    }
}

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; //Per Definition können Eltern und Kind auf geschützte Kinder verweisen
    }

    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); //Eine Instanz dieser ChildClass($child)Und ich selber($parent)Auch wenn es keine direkte Beziehung zu zu geben scheint
$parent->callChildFunction($child);

child child_function

Natürlich kann man nicht ohne Erweiterungen lesen

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

Beiseite

Private derselben Klasse können gelesen werden, auch wenn die Instanzen getrennt sind

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

In anderen Sprachen ist es fast dasselbe. Probieren Sie es aus