PHP: Zugriffskontrolle und statisches Schlüsselwort

1. Zugriffskontrolle in PHP

Zugriffskontrolle umfasst: öffentlich, privat, geschützt

Zugriffskontrolle (Sichtbarkeit)

Ja Zugriffskontrolle von Attributen oder Methoden wird erreicht, indem man davor die Schlüsselwörter public, protected oder private einfügt. Auf Klassenmitglieder, die als öffentlich definiert sind, kann von überall aus zugegriffen werden. Auf ein als geschützt definiertes Klassenmitglied kann von ihm selbst und seinen Unterklassen und übergeordneten Klassen zugegriffen werden. Als privat definierte Klassenmitglieder können nur von der Klasse aufgerufen werden, in der sie definiert sind.

Zugriffskontrolle von Attributen

Klassenattribute müssen als öffentlich, geschützt oder privat definiert werden. Wenn es mit var definiert ist, gilt es als öffentlich.

Beispiel Nr. 1 Eigenschaftsdeklaration

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = &#39;Public&#39;;
    protected $protected = &#39;Protected&#39;;
    private $private = &#39;Private&#39;;
    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}
$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private
/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以对 public 和 protected 进行重定义，但 private 而不能
    protected $protected = &#39;Protected2&#39;;
    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}
$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
?>

Hinweis: Aus Kompatibilitätsgründen ist die Methode zur Verwendung des Schlüsselworts var zum Definieren von Variablen in PHP 4 in PHP 5 weiterhin gültig (genau wie ein Alias). für das Schlüsselwort public). In Versionen vor PHP 5.1.3 erzeugte diese Syntax eine E_STRICT-Warnung.

Methodenzugriffskontrolle

Methoden in einer Klasse können als öffentlich, privat oder geschützt definiert werden. Wenn diese Schlüsselwörter nicht festgelegt sind, ist die Methode standardmäßig öffentlich.

Beispiel Nr. 2 Methodendeklaration

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 声明一个公有的构造函数
    public function construct() { }
    // 声明一个公有的方法
    public function MyPublic() { }
    // 声明一个受保护的方法
    protected function MyProtected() { }
    // 声明一个私有的方法
    private function MyPrivate() { }
    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}
$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行
/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 此方法为公有
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 这行会产生一个致命错误
    }
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行
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
?>

Zugriffskontrolle anderer Objekte

Objekte derselben Klasse können auf die privaten und Objekteigenschaften des jeweils anderen zugreifen, auch wenn sie nicht die gleichen sind gleiche Instanz. Mitglieder schützen. Dies liegt daran, dass die internen Implementierungsdetails dieser Objekte bekannt sind.

Beispiel #3 Zugriff auf private Mitglieder desselben Objekttyps

<?php
class Test
{
    private $foo;
    public function construct($foo)
    {
        $this->foo = $foo;
    }
    private function bar()
    {
        echo &#39;Accessed the private method.&#39;;
    }
    public function baz(Test $other)
    {
        // We can change the private property:
        $other->foo = &#39;hello&#39;;
        var_dump($other->foo);
        // We can also call the private method:
        $other->bar();
    }
}
$test = new Test(&#39;test&#39;);
$test->baz(new Test(&#39;other&#39;));
?>

Die obige Routine gibt Folgendes aus:

string(5) "hello"
Accessed the private method.

3 Statisches Schlüsselwort

Statisches (statisches) Schlüsselwort

Tipp

Auf dieser Seite wird die Verwendung des statischen Schlüsselworts zum Definieren statischer Methoden und Eigenschaften erläutert. static kann auch zum Definieren statischer Variablen und später statischer Bindung verwendet werden. Sehen Sie sich die obige Seite an, um zu sehen, wie statisch dort verwendet wird.

Wenn Sie ein Klassenattribut oder eine Methode als statisch deklarieren, können Sie direkt darauf zugreifen, ohne die Klasse zu instanziieren. Auf statische Eigenschaften kann nicht über ein Objekt einer instanziierten Klasse zugegriffen werden (statische Methoden jedoch schon).

Aus Gründen der Kompatibilität mit PHP 4 sind Eigenschaften und Methoden standardmäßig öffentlich, wenn keine Zugriffskontrolle angegeben ist.

Da statische Methoden nicht über Objekte aufgerufen werden müssen, ist die Pseudovariable $this in statischen Methoden nicht verfügbar.

Auf statische Eigenschaften kann von Objekten nicht über den ->-Operator zugegriffen werden. Der statische Aufruf einer nicht statischen Methode führt zu einem Fehler auf E_STRICT-Ebene.

Wie alle anderen statischen PHP-Variablen können statische Eigenschaften nur als Literale oder Konstanten initialisiert werden und können keine

Ausdrücke

verwenden. Eine statische Eigenschaft kann also mit einer Ganzzahl oder einem Array initialisiert werden, sie kann jedoch nicht mit einem anderen Variablen- oder Funktionsrückgabewert initialisiert werden und kann auch nicht auf ein Objekt verweisen. Seit PHP 5.3.0 können Sie eine Variable verwenden, um eine Klasse dynamisch aufzurufen. Der Wert dieser Variablen darf jedoch nicht die Schlüsselwörter self, parent oder static sein.

Beispiel #1 Beispiel für eine statische Eigenschaft

Das obige ist der detaillierte Inhalt vonPHP: Zugriffskontrolle und statisches Schlüsselwort. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!