array ( 0 => 'index.php', 1 => 'PHP Manual', ), 'head' => array ( 0 => 'UTF-8', 1 => 'pt_BR', ), 'this' => array ( 0 => 'language.oop5.visibility.php', 1 => 'Visibilidade', ), 'up' => array ( 0 => 'language.oop5.php', 1 => 'Classes e Objetos', ), 'prev' => array ( 0 => 'language.oop5.decon.php', 1 => 'Construtores e Destrutores', ), 'next' => array ( 0 => 'language.oop5.inheritance.php', 1 => 'Herança de Objetos', ), 'alternatives' => array ( ), 'source' => array ( 'lang' => 'pt_BR', 'path' => 'language/oop5/visibility.xml', ), ); $setup["toc"] = $TOC; $setup["toc_deprecated"] = $TOC_DEPRECATED; $setup["parents"] = $PARENTS; manual_setup($setup); ?>
A visibilidade de uma propriedade ou método ou constante pode ser definida prefixando a
declaração com as palavras-chave public
,
protected
ou
private
. Membros de classes declarados como públicos podem ser
acessados de qualquer lugar. Membros declarados como protegidos pode ser acessados
na própria classe ou de classes referenciadas por herança
acima. Membros declarados como privados só podem ser acessados por classes
que definem esse membro.
Propriedades de classes podem ser declarados como públicas, privadas ou protegidas. Propriedades declaradas sem visibilidade são definidas como públicas.
Exemplo #1 Declaração de propriedade
<?php
/**
* Define MinhaClasse
*/
class MinhaClasse
{
public $publica = 'Public';
protected $protegida = 'Protected';
private $privada = 'Private';
function imprimeAlo()
{
echo $this->publica;
echo $this->protegida;
echo $this->privada;
}
}
$obj = new MinhaClasse();
echo $obj->publica; // Funciona
echo $obj->protegida; // Erro Fatal
echo $obj->privada; // Erro Fatal
$obj->imprimeAlo(); // Mostra Public, Protected e Private
/**
* Define MinhaClasse2
*/
class MinhaClasse2 extends MinhaClasse
{
// Nós podemos redeclarar as propriedades públicas e protegidas mas não as privadas
public $publica = 'Public2';
protected $protegida = 'Protected2';
function imprimeAlo()
{
echo $this->publica;
echo $this->protegida;
echo $this->privada;
}
}
$obj2 = new MinhaClasse2();
echo $obj2->publica; // Funciona
echo $obj2->protegida; // Erro fatal
echo $obj2->privada; // Não definida
$obj2->imprimeAlo(); // Mostra Public, Protected2, Undefined
?>
Métodos de classe podem ser definidos como público, privado ou protegido. Métodos sem qualquer declaração explícita serão definidos como público.
Exemplo #2 Declaração de método
<?php
/**
* Define MinhaClasse
*/
class MinhaClasse
{
// Declara um construtor público
public function __construct() { }
// Declara um método public
public function MeuPublico() { }
// Declara um método protected
protected function MeuProtegido() { }
// Declara um método private
private function MeuPrivado() { }
// Esse é public
function Foo()
{
$this->MeuPublico();
$this->MeuProtegido();
$this->MeuPrivado();
}
}
$minhaclasse = new MinhaClasse;
$minhaclasse->MeuPublico(); // Funciona
$minhaclasse->MeuProtegido(); // Erro Fatal
$minhaclasse->MeuPrivado(); // Erro Fatal
$minhaclasse->Foo(); // Public, Protected e Private funcionam
/**
* Define MinhaClasse2
*/
class MinhaClasse2 extends MinhaClasse
{
// Esse é public
function Foo2()
{
$this->MeuPublico();
$this->MeuProtegido();
$this->MeuPrivado(); // Erro Fatal
}
}
$minhaclasse2 = new MinhaClasse2;
$minhaclasse2->MeuPublico(); // Funciona
$minhaclasse2->Foo2(); // Public e Protected funcionam, Private não
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 do PHP 7.1.0, constantes de classe podem ser definidas como públicas, protegidas ou privadas. Constantes declaradas sem visibilidade explícita são definidas como públicas.
Exemplo #3 Declaração de constantes (desde o PHP 7.1.0)
<?php
/**
* Define MyClass
*/
class MyClass
{
// Declara uma constante pública
public const MY_PUBLIC = 'public';
// Declara uma constante protegida
protected const MY_PROTECTED = 'protected';
// Declara uma 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; // Erro fatal
MyClass::MY_PRIVATE; // Erro fatal
$myclass->foo(); // Todos os acessos funcionam dentro do método
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// This is public
function foo2()
{
echo self::MY_PUBLIC;
echo self::MY_PROTECTED;
echo self::MY_PRIVATE; // Fatal Error
}
}
$myclass2 = new MyClass2;
echo MyClass2::MY_PUBLIC; // Funciona
$myclass2->foo2(); // Public and Protected funcionam, mas não Private
?>
Objetos do mesmo tipo terão acesso a outros mementos privados e protegidos mesmo que não sejam da mesma instância. Isso acontece por que os detalhes específicos de implementação já são conhecidos dentro destes objetos.
Exemplo #4 Acessando membros privados entre objetos do mesmo tipo
<?php
class Test
{
private $foo;
public function __construct($foo)
{
$this->foo = $foo;
}
private function bar()
{
echo 'Acessou o método privado.';
}
public function baz(Test $other)
{
// Pode-se alterar a propriedade privada:
$other->foo = 'hello';
var_dump($other->foo);
// Pode-se chamar método privado:
$other->bar();
}
}
$test = new Test('test');
$test->baz(new Test('other'));
?>
O exemplo acima produzirá:
string(5) "hello" Acessou o método privado.