La visibilidad de una propiedad, un método o (a partir de PHP 7.1.0) una constante puede
ser definida prefijando su declaración con una palabra clave: public
,
protected
, o
private
.
Los elementos declarados como públicos son accesibles en cualquier lugar.
El acceso a los elementos protegidos está limitado a la clase misma, así
como a las clases que heredan de ella y a la clase padre.
El acceso a los elementos privados está reservado únicamente a la clase que los ha definido.
Las propiedades de las clases pueden ser definidas como públicas, privadas o protegidas. Las propiedades declaradas sin utilizar explícitamente una palabra clave de visibilidad serán automáticamente definidas como públicas.
Ejemplo #1 Declaración de propiedades
<?php
/**
* Definición de MyClass
*/
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; // Funciona
echo $obj->protected; // Error fatal
echo $obj->private; // Error fatal
$obj->printHello(); // Muestra Public, Protected y Private
/**
* Definición de MyClass2
*/
class MyClass2 extends MyClass
{
// Se pueden redeclarar las propiedades públicas o protegidas, pero no las privadas
public $public = 'Public2';
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // Funciona
echo $obj2->protected; // Error fatal
echo $obj2->private; // Indefinido
$obj2->printHello(); // Muestra Public2, Protected2 y Undefined (Indefinido)
?>
A partir de PHP 8.4, las propiedades pueden también tener su
visibilidad definida de manera asimétrica, con un campo diferente para
la lectura (get
) y la escritura (set
).
Más precisamente, la visibilidad set
puede ser
especificada separadamente, siempre que no sea más permisiva que la
visibilidad por defecto.
Ejemplo #2 Visibilidad Asimétrica de las Propiedades
<?php
class Book
{
public function __construct(
public private(set) string $title,
public protected(set) string $author,
protected private(set) int $pubYear,
) {}
}
class SpecialBook extends Book
{
public function update(string $author, int $year): void
{
$this->author = $author; // OK
$this->pubYear = $year; // Error Fatal
}
}
$b = new Book('Cómo usar PHP', 'Peter H. Peterson', 2024);
echo $b->title; // Funciona
echo $b->author; // Funciona
echo $b->pubYear; // Error Fatal
$b->title = 'Cómo no usar PHP'; // Error Fatal
$b->author = 'Pedro H. Peterson'; // Error Fatal
$b->pubYear = 2023; // Error Fatal
?>
Hay algunas reservas concernientes a la visibilidad asimétrica:
set
separada.
set
debe ser la misma
que get
o más restrictiva. Es decir,
public protected(set)
y protected protected(set)
están permitidos, pero protected public(set)
provocará un error de sintaxis.
public
, entonces la visibilidad principal puede ser
omitida. Es decir, public private(set)
y private(set)
tendrán el mismo resultado.
private(set)
es automáticamente final
, y no puede ser redefinida en una clase hija.
set
, no get
.
Esto se debe a que una referencia puede ser utilizada para modificar el valor de la propiedad.
get
como
una operación set
internamente, y seguirá por lo tanto la visibilidad set
,
ya que es siempre la más restrictiva.
Nota: Los espacios no están permitidos en la declaración de visibilidad para la modificación.
private(set)
es correcto.private( set )
no es correcto y resultará en un error de análisis.
Cuando una clase extiende a otra, la clase hija puede redefinir
cualquier propiedad que no sea final
. Al hacerlo,
puede ampliar tanto la visibilidad principal como la visibilidad set
,
siempre que la nueva visibilidad sea la misma o más amplia
que la de la clase padre. Sin embargo, tenga en cuenta que si una propiedad private
es reemplazada, esto no cambia realmente la propiedad de la clase padre,
sino que crea una nueva propiedad con un nombre interno diferente.
Ejemplo #3 Herencia de Propiedades Asimétricas
<?php
class Book
{
protected string $title;
public protected(set) string $author;
protected private(set) int $pubYear;
}
class SpecialBook extends Book
{
public protected(set) $title; // OK, ya que la lectura es más amplia y la escritura es la misma.
public string $author; // OK, ya que la lectura es la misma y la escritura es más amplia.
public protected(set) int $pubYear; // Error Fatal. Las propiedades private(set) son finales.
}
?>
Los métodos de las clases pueden ser definidos como públicos, privados o protegidos. Los métodos declarados sin utilizar explícitamente una palabra clave de visibilidad serán automáticamente definidos como públicos.
Ejemplo #4 Declaración de métodos
<?php
/**
* Definición de MyClass
*/
class MyClass
{
// Declara un constructor público
public function __construct() { }
// Declara un método público
public function MyPublic() { }
// Declara un método protegido
protected function MyProtected() { }
// Declara un método privado
private function MyPrivate() { }
// Este será público
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // Funciona
$myclass->MyProtected(); // Error fatal
$myclass->MyPrivate(); // Error fatal
$myclass->Foo(); // Public, Protected y Private funcionan
/**
* Definición de MyClass2
*/
class MyClass2 extends MyClass
{
// Este será público
function Foo2()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // Error fatal
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Funciona
$myclass2->Foo2(); // Public y Protected funcionan, no 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
?>
A partir de PHP 7.1.0, las constantes de clases pueden ser definidas como públicas, privadas o protegidas. Las constantes declaradas sin una palabra clave de visibilidad explícita son definidas como públicas.
Ejemplo #5 Declaración de constantes a partir de PHP 7.1.0
<?php
/**
* Declaremos MyClass
*/
class MyClass
{
// Declaremos una constante pública
public const MY_PUBLIC = 'public';
// Declaremos una constante protegida
protected const MY_PROTECTED = 'protected';
// Declaremos una constante privada
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; // Funciona
MyClass::MY_PROTECTED; // Error fatal
MyClass::MY_PRIVATE; // Error fatal
$myclass->foo(); // Public, Protegida y Privada funcionan
/**
* Definir MyClass2
*/
class MyClass2 extends MyClass
{
// Esto es público
function foo2()
{
echo self::MY_PUBLIC;
echo self::MY_PROTECTED;
echo self::MY_PRIVATE; // Error fatal
}
}
$myclass2 = new MyClass2;
echo MyClass2::MY_PUBLIC; // Funciona
$myclass2->foo2(); // Public y Protegida funcionan, pero no Privada
?>
Los objetos de mismos tipos tienen acceso a los miembros privados y protegidos de los otros, incluso si no son la misma instancia. Esto se debe a que los detalles específicos de la implementación ya son conocidos internamente por estos objetos.
Ejemplo #6 Acceso a los miembros privados de un objeto del mismo tipo
<?php
class Test
{
private $foo;
public function __construct($foo)
{
$this->foo = $foo;
}
private function bar()
{
echo 'Acceso al método privado.';
}
public function baz(Test $other)
{
// Podemos modificar la propiedad privada:
$other->foo = 'Hola';
var_dump($other->foo);
// También podemos llamar al método privado:
$other->bar();
}
}
$test = new Test('test');
$test->baz(new Test('other'));
?>
El resultado del ejemplo sería:
string(5) "Hola" Acceso al método privado.