Sichtbarkeit

    Die Sichtbarkeit einer Eigenschaft, Methode oder (von PHP 7.1.0 an) einer Konstante kann definiert werden, indem man der Deklaration eines der Schlüsselwörter public, protected oder private voranstellt. Auf public deklarierte Elemente kann von überall her zugegriffen werden. Protected beschränkt den Zugang auf Elternklassen und abgeleitete Klassen (sowie die Klasse, die das Element definiert). Private grenzt die Sichtbarkeit einzig auf die Klasse ein, die das Element definiert.

    Sichtbarkeit von Membern

    Klasseneigenschaften können als public, private oder protected definiert werden. Eigenschaften, die ohne explizites Schlüsselwort für die Sichtbarkeit deklariert sind, werden als public definiert.

    Beispiel #1 Eigenschaftendeklaration

    <?php

    class MyClass
    {
    public     $public = 'Public';
    protected     $protected = 'Protected';
    private     $private = 'Private';

    function     printHello()
    {
    echo     $this->public;
    echo     $this->protected;
    echo     $this->private;
    }
    }

    $obj = new MyClass();
    echo     $obj->public; // Funktioniert
    echo $obj->protected; // Fataler Fehler
    echo $obj->private; // Fataler Fehler
    $obj->printHello(); // Zeigt Public, Protected und Private



    class MyClass2 extends MyClass
    {
    // Wir können die public- und protected-Eigenschaften neu deklarieren,

    Sichtbarkeit von Methoden

    Klassenmethoden müssen mit public, private oder protected definiert werden. Methoden ohne jede explizite Deklaration sind als public definiert.

    Beispiel #2 Methodendeklaration

    <?php

    class MyClass
    {
    // Deklariert einen public Konstruktor
    public function __construct() { }

    // Deklariere eine public Funktion
    public function MyPublic() { }

    // Deklariere eine protected Funktion
    protected function MyProtected() { }

    // Deklariere eine private Funktion
    private function MyPrivate() { }

    // Dies ist public
    function Foo()
    {
    $this->MyPublic();
    $this->MyProtected();
    $this->MyPrivate();
    }
    }

    $myclass = new MyClass;
    $myclass->MyPublic(); // Funktioniert
    $myclass->MyProtected(); // Fataler Fehler
    $myclass->MyPrivate(); // Fataler Fehler
    $myclass->Foo(); // Public, Protected und Private funktionieren



    class MyClass2 extends MyClass
    {
    // Dies ist public
    function Foo2()
    {
    $this->MyPublic();
    $this->MyProtected();
    $this->MyPrivate(); // Fataler Fehler
    }
    }

    $myclass2 = new MyClass2;
    $myclass2->MyPublic(); // Funktioniert
    $myclass2->Foo2(); // Public und Protected funktionieren, Private nicht

    class Bar
    {
    public function     test() {
    $this->testPrivate();
    $this->testPublic();
    }

    public function     testPublic() {
    echo     "Bar::testPublic\n";
    }

    private function     testPrivate() {
    echo     "Bar::testPrivate\n";
    }
    }

    class     Foo extends Bar
    {
    public function     testPublic() {
    echo     "Foo::testPublic\n";
    }

    private function     testPrivate() {
    echo     "Foo::testPrivate\n";
    }
    }

    $myFoo = new Foo();
    $myFoo->test(); // Bar::testPrivate

    Sichtbarkeit von Konstanten

    Von PHP 7.1.0 an können Klassenkonstanten als public, private, oder protected definiert werden. Konstanten, die ohne eine explizite Sichtbarkeitsangabe deklariert wurden, sind public.

    Beispiel #3 Konstantendeklaration von PHP 7.1.0 an

    <?php

    class MyClass
    {
    // Deklariere eine öffentliche Konstante
    public const MY_PUBLIC = 'öffentlich';

    // Deklariere eine geschützte Konstante
    protected const MY_PROTECTED = 'geschützt';

    // Deklariere eine private Konstante
    private const MY_PRIVATE = 'privat';

    public function     foo()
    {
    echo     self::MY_PUBLIC;
    echo     self::MY_PROTECTED;
    echo     self::MY_PRIVATE;
    }
    }

    $myclass = new MyClass();
    MyClass::MY_PUBLIC; // funktioniert
    MyClass::MY_PROTECTED; // fataler Fehler
    MyClass::MY_PRIVATE; // fataler Fehler
    $myclass->foo(); // öffentlich, geschützt und private funktioniert



    class MyClass2 extends MyClass
    {
    // Dies ist öffentlich
    function foo2()
    {
    echo     self::MY_PUBLIC;
    echo     self::MY_PROTECTED;
    echo     self::MY_PRIVATE; // fataler Fehler
    }
    }

    $myclass2 = new MyClass2;
    echo     MyClass2::MY_PUBLIC; // funktioniert
    $myclass2->foo2(); // öffentlich und geschützt funktioniert, aber nicht privat
    ?>

    Sichtbarkeit von anderen Objekten

    Objekte des gleichen Types haben untereinander Zugriff auf die als private und protected markierten Member, obwohl es sich nicht um die gleichen Instanzen handelt. Dies liegt daran, dass die Details über die Implementierung innerhalb solcher Objekte bekannt sind.

    Beispiel #4 Zugriff auf als private markierte Member des gleichen Objekttyps

    <?php
    class Test
    {
    private     $foo;

    public function     __construct($foo)
    {
    $this->foo = $foo;
    }

    private function     bar()
    {
    echo     'Zugriff auf die private Methode';
    }

    public function     baz(Test $other)
    {
    // Ändern der privaten Eigenschaft ist möglich:
    $other->foo = 'Hallo';
    var_dump($other->foo);

    // Aufruf der privaten Methode ist ebenfalls möglich:
    $other->bar();
    }
    }

    $test = new Test('test');

    $test->baz(new Test('other'));
    ?>

    Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

     string(5) "Hallo" Zugriff auf die private Methode +
    To Top