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.
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
public $membru_public = 'Public2';
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.
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
?>
Începând cu PHP 7.1.0, constantele dintr-o clasă pot fi definite publice, private, sau protejate. Constantele declarate fără o vizilibitate explicită sunt considerate publice.
Example #3 Declararea constantelor începând cu PHP 7.1.0
<?php
/**
* Definește clasa MyClass
*/
class MyClass
{
// Declară o constantă publică
public const MY_PUBLIC = 'public';
// Declară o constantă protejată
protected const MY_PROTECTED = 'protected';
// Declară o constantă privată
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; // Funcționează
MyClass::MY_PROTECTED; // Eroare fatală
MyClass::MY_PRIVATE; // Eroare fatală
$myclass->foo(); // Publice, protejate și private funcționează
/**
* Definește clasa MyClass2
*/
class MyClass2 extends MyClass
{
// Metodă publică
function foo2()
{
echo self::MY_PUBLIC;
echo self::MY_PROTECTED;
echo self::MY_PRIVATE; // Eroare fatală
}
}
$myclass2 = new MyClass2;
echo MyClass2::MY_PUBLIC; // Funcționează
$myclass2->foo2(); // Publice, protejate și private funcționează
?>
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 #4 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ă.