Vizibilitatea

Vizibilitatea unei propietăți sau a unei metode poate fi definită prefixând declarația cu unul din cuvintele cheie: public, protected sau private. Membrele claselor (proprietăți sau metode) declarate public pot fi accesate oriunde. Membrele declarate protected pot fi accesate doar în interiorul clasei, precum și de clasele moștenite. Membrele declarate private pot fi accesate doar de clasa care le definește.

Vizibilitatea proprietăților

Proprietățile unei clase trebuie definite ca public, private, sau protected. Dacă sunt declarate utilizând var, proprietatea va fi definită ca publică.

Example #1 Declarare proprietăților


<?php
/**
 * Definire ClassaMea
 */
class ClassaMea
{
    public $membru_public = 'Eu sunt: Public';
    protected $membru_protected = 'Eu sunt: Protected';
    private $membru_private = 'Eu sunt: Private';

    function afiseazaBunaZiua()
    {
        echo $this->membru_public . ", ";
        echo $this->membru_protected . ", ";
        echo $this->membru_private;
    }
}

$obj = new ClassaMea();
echo $obj->membru_public;    // Funcționează
echo $obj->membru_protected; // Eroare fatală
echo $obj->membru_private;   // Eroare fatală
$obj->afiseazaBunaZiua();    // Afișează Eu sunt: Public, Eu sunt: Protected, Eu sunt: Private

/**
 * Define ClassaMea2
 */
class ClassaMea2 extends ClassaMea
{
    // Putem redeclara metodele publice și protected, dar nu și pe cele private
    protected $membru_protected = 'Eu sunt: Protected2';

    function afiseazaBunaZiua()
    {
        echo $this->membru_public . ",";
        echo $this->membru_protected;
        echo $this->membru_private;
    }
}

$obj2 = new ClassaMea2();
echo $obj->membru_public;     // Funcționează
echo $obj2->membru_protected; // Eroare fatală
echo $obj2->membru_private;   // Nedefinit
$obj2->afiseazaBunaZiua();    // Afișează Eu sunt: Public, Eu sunt: Protected2

?>

Notă: Metoda PHP 4 de a declara variabile folosind cuvântul cheie var este încă susținută din motive de compatibilitate (fiind sinonim cuvântului cheie public). În PHP 5 înainte de 5.1.3, utilizarea sa va emite o avertizare de tip E_STRICT.

Vizibilitatea metodelor

Metodele claselor pot fi definite ca public, private, sau protected. Metodele declarate fără un cuvânt-cheie de vizibilitate sunt definite ca publice.

Example #2 Declarație metode


<?php
/**
 * Definește MyClass
 */
class MyClass
{
    // Declară un constructor public
    public function __construct() { }

    // Declară o metodă publică
    public function MyPublic() { }

    // Declară o metodă protected
    protected function MyProtected() { }

    // Declară o metodă private
    private function MyPrivate() { }

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

$myclass = new MyClass;
$myclass->MyPublic(); // Funcționează
$myclass->MyProtected(); // Eroare fatală
$myclass->MyPrivate(); // Eroare fatală
$myclass->Foo(); // Cele Public, Protected și Private funcționează


/**
 * Definește MyClass2
 */
class MyClass2 extends MyClass
{
    // Aceasta este public
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // Eroare fatală
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Funcționează
$myclass2->Foo2(); // Public și Protected funcționează, dar nu și 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
                // Foo::testPublic
?>

Vizibilitatea din cadrul altor obiecte

Obiectele de același tip vor avea acces reciproc la membrele private și protejate, cu toate că nu reprezintă aceeași instanță. Aceasta se întâmplă din cauza că detaliile specifice de implementare se cunosc deja în interiorul acestor obiecte.

Example #3 Accesarea membrelor private ale unui obiect de același tip


<?php
class Test
{
    private $foo;

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

    private function bar()
    {
        echo 'S-a accesat metoda privată.';
    }

    public function baz(Test $other)
    {
        // Putem modifica proprietatea privată:
        $other->foo = 'salut';
        var_dump($other->foo);

        // Putem de asemenea apela metoda privată:
        $other->bar();
    }
}

$test = new Test('test');

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

Exemplul de mai sus va afișa:

string(5) "salut"
S-a accesat metoda privată.