php : contrôle d'accès et mot-clé statique

1. Contrôle d'accès en Php

Le contrôle d'accès comprend : public, privé, protégé

Contrôle d'accès (visibilité)

Oui Contrôle d'accès d'attributs ou de méthodes est obtenu en ajoutant devant lui les mots-clés public, protected ou private. Les membres de la classe définis comme publics sont accessibles de n’importe où. Les membres de la classe définis comme protégés sont accessibles par lui-même ainsi que par ses sous-classes et classes parentes. Les membres de classe définis comme privés ne sont accessibles que par la classe dans laquelle ils sont définis.

Contrôle d'accès des attributs

Les attributs de classe doivent être définis comme étant publics, protégés et privés. S'il est défini avec var, il est considéré comme public.

Exemple #1 Déclaration de propriété

<?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
?>

Remarque : Pour des raisons de compatibilité, la méthode d'utilisation du mot-clé var pour définir des variables en PHP 4 est toujours valable en PHP 5 (tout comme un alias pour le mot-clé public). Dans les versions antérieures à PHP 5.1.3, cette syntaxe produisait un avertissement E_STRICT.

Contrôle d'accès aux méthodes

Les méthodes d'une classe peuvent être définies comme publiques, privées ou protégées. Si ces mots-clés ne sont pas définis, la méthode est par défaut publique.

Exemple #2 Déclaration de méthode

<?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
?>

Contrôle d'accès d'autres objets

Les objets de la même classe peuvent accéder les uns aux autres aux propriétés privées et d'objet même s'ils ne sont pas les même exemple. Protéger les membres. En effet, les détails d'implémentation interne de ces objets sont connus.

Exemple n°3 Accéder aux membres privés du même type d'objet

<?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;));
?>

La routine ci-dessus affichera :

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

3 mots-clés statiques

Mot-clé statique (statique)

Astuce

Cette page explique l'utilisation du mot-clé statique pour définir des méthodes et propriétés statiques. static peut également être utilisé pour définir des variables statiques et des liaisons statiques tardives . Voir la page ci-dessus pour voir comment la statique y est utilisée.

Déclarer un attribut ou une méthode de classe comme statique vous permet d'y accéder directement sans instancier la classe. Les propriétés statiques ne sont pas accessibles via un objet d'une classe qui a été instanciée (mais les méthodes statiques le peuvent).

Pour la compatibilité avec PHP 4, si aucun contrôle d'accès n'est spécifié, propriétés et méthodes par défaut sont publiques.

Étant donné que les méthodes statiques n'ont pas besoin d'être appelées via des objets, la pseudo variable $this n'est pas disponible dans les méthodes statiques.

Les propriétés statiques ne sont pas accessibles aux objets via l'opérateur.

L'appel statique d'une méthode non statique entraînera une erreur de niveau E_STRICT.

Comme toutes les autres variables statiques PHP, les propriétés statiques ne peuvent être initialisées qu'avec des littéraux ou des constantes, et ne peuvent pas utiliser d'expressions. Ainsi, une propriété statique peut être initialisée avec un entier ou un tableau, mais elle ne peut pas être initialisée avec une autre valeur de retour de variable ou de fonction, ni pointer vers un objet.

Depuis PHP 5.3.0, vous pouvez utiliser une variable pour appeler dynamiquement une classe. Mais la valeur de cette variable ne peut pas être les mots-clés self, parent ou static.

Exemple n°1 Exemple de propriété statique

<?php
class Foo
{
    public static $my_static = &#39;foo&#39;;
    public function staticValue() {
        return self::$my_static;
    }
}
class Bar extends Foo
{
    public function fooStatic() {
        return parent::$my_static;
    }
}
print Foo::$my_static . "\n";
$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n";      // Undefined "Property" my_static 
print $foo::$my_static . "\n";
$classname = &#39;Foo&#39;;
print $classname::$my_static . "\n"; // As of PHP 5.3.0
print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>
   </programlisting>
  </example>
  <example>
   <title>静态方法示例</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo {
    public static function aStaticMethod() {
        // ...
    }
}
Foo::aStaticMethod();
$classname = &#39;Foo&#39;;
$classname::aStaticMethod(); // 自 PHP 5.3.0 起
?>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!