Visibilité

    La visibilité d'une propriété, d'une méthode ou (à partir de PHP 7.1.0) une constante peut être définie en préfixant sa déclaration avec un mot-clé : public, protected, ou private. Les éléments déclarés comme publics sont accessibles partout. L'accès aux éléments protégés est limité à la classe elle-même, ainsi qu'aux classes qui en héritent et parente. L'accès aux éléments privés est uniquement réservé à la classe qui les a définis.

    Visibilité des propriétés

    Les propriétés des classes peuvent être définies comme publiques, privées ou protégées. Les propriétés déclarées sans explicitement utiliser un mot-clef de visibilité seront automatiquement définies comme publiques.

    Exemple #1 Déclaration de propriétés

    <?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; // Fonctionne
    echo $obj->protected; // Erreur fatale
    echo $obj->private; // Erreur fatale
    $obj->printHello(); // Affiche Public, Protected et Private



    class MyClass2 extends MyClass
    {
    // On peut redéclarer les propriétés publics ou protégés, mais pas ceux privés
    public $public = 'Public2';
    protected     $protected = 'Protected2';

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

    $obj2 = new MyClass2();
    echo     $obj2->public; // Fonctionne
    echo $obj2->protected; // Erreur fatale
    echo $obj2->private; // Indéfini
    $obj2->printHello(); // Affiche Public2, Protected2 et Undefined (Indéfini)

    ?>

    Visibilité des méthodes

    Les méthodes des classes peuvent être définies comme publiques, privées ou protégées. Les méthodes déclarées sans explicitement utiliser un mot-clef de visibilité seront automatiquement définies comme publiques.

    Exemple #2 Déclaration de méthodes

    <?php

    class MyClass
    {
    // Déclare un constructeur public
    public function __construct() { }

    // Déclare une méthode publique
    public function MyPublic() { }

    // Déclare une méthode protégée
    protected function MyProtected() { }

    // Déclare une méthode privée
    private function MyPrivate() { }

    // Celle-ci sera publique
    function Foo()
    {
    $this->MyPublic();
    $this->MyProtected();
    $this->MyPrivate();
    }
    }

    $myclass = new MyClass;
    $myclass->MyPublic(); // Fonctionne
    $myclass->MyProtected(); // Erreur fatale
    $myclass->MyPrivate(); // Erreur fatale
    $myclass->Foo(); // Public, Protected et Private fonctionnent



    class MyClass2 extends MyClass
    {
    // Celle-ci sera publique
    function Foo2()
    {
    $this->MyPublic();
    $this->MyProtected();
    $this->MyPrivate(); // Erreur fatale
    }
    }

    $myclass2 = new MyClass2;
    $myclass2->MyPublic(); // Fonctionne
    $myclass2->Foo2(); // Public et Protected fonctionnent, non Private

    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

    Constant Visibility

    À partir de PHP 7.1.0, les constantes de classes peuvent être définies comme public, privée ou protégée. Les constantes déclarées sans mot clé de visibilité explicite sont définies en tant que public.

    Exemple #3 Déclaration de constantes à partir de PHP 7.1.0

    <?php

    class MyClass
    {
    // Déclarons une constante public
    public const MY_PUBLIC = 'public';

    // Déclarons une constante protégée
    protected const MY_PROTECTED = 'protected';

    // Déclarons une constante privée
    private const MY_PRIVATE = 'private';

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

    $myclass = new MyClass();
    MyClass::MY_PUBLIC; // Fonctionne
    MyClass::MY_PROTECTED; // Erreur fatale
    MyClass::MY_PRIVATE; // Erreur fatale
    $myclass->foo(); // Public, Protégée et Privée fonctionne



    class MyClass2 extends MyClass
    {
    // This is public
    function foo2()
    {
    echo     self::MY_PUBLIC;
    echo     self::MY_PROTECTED;
    echo     self::MY_PRIVATE; // Erreur fatale
    }
    }

    $myclass2 = new MyClass2;
    echo     MyClass2::MY_PUBLIC; // Fonctionne
    $myclass2->foo2(); // Public et Protégée fonctionne, mais pas Privée
    ?>

    Visibilité depuis d'autres objets

    Les objets de mêmes types ont accès aux membres privés et protégés les uns des autres, même s'ils ne sont pas la même instance. Ceci est dû au fait que les détails spécifiques de l'implémentation sont déjà connus en interne par ces objets.

    Exemple #4 Accès aux membres privés d'un objet du même type

    <?php
    class Test
    {
    private     $foo;

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

    private function     bar()
    {
    echo     'Accès à la méthode privée.';
    }

    public function     baz(Test $other)
    {
    // Nous pouvons modifier la propriété privée :
    $other->foo = 'Bonjour';
    var_dump($other->foo);

    // Nous pouvons également appeler la méthode privée :
    $other->bar();
    }
    }

    $test = new Test('test');

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

    L'exemple ci-dessus va afficher :

     string(7) "Bonjour" Accès à la méthode privée.
    To Top