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
/**
* Definiere MyClass
*/
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
/**
* Definiere MyClass2
*/
class MyClass2 extends MyClass
{
// Wir können die public- und protected-Eigenschaften neu deklarieren,
// aber nicht die private
public $public = 'Public2';
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // Funktioniert
echo $obj2->protected; // Fataler Fehler
echo $obj2->private; // Undefiniert
$obj2->printHello(); // Zeigt Public2, Protected2, Undefined
?>
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
/**
* Definiere MyClass
*/
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
/**
* Definiere MyClass2
*/
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
// Foo::testPublic
?>
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
/**
* Definiere MyClass
*/
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
/**
* Definiere MyClass2
*/
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 +
