Métodos de acesso e permissões de membros da classe PHP

Os métodos de acesso do PHP5 permitem restringir o acesso aos membros da classe. Este é um novo recurso do PHP5, mas já existe em muitas linguagens orientadas a objetos. Com métodos de acesso, você pode desenvolver um aplicativo orientado a objetos confiável e construir objetos reutilizáveis. biblioteca de classes orientada.

Assim como C++ e Java, o PHP possui três métodos de acesso: público, privado e protegido. Para o método de acesso de um membro da classe, pode ser um deles. Se você não especificar o método de acesso, o acesso é por padrão. O método é público. Você também pode especificar um método de acesso para membros estáticos colocando o método de acesso antes da palavra-chave estática (como

membros públicos estáticos podem ser acessados ​​sem restrições

. Você pode chamar um método público de qualquer lugar em seu script. Nas versões anteriores do PHP, todos os métodos e propriedades eram públicos, o que fazia com que os objetos parecessem arrays bem estruturados.

Visíveis apenas dentro da classe.

apenas

métodos dentro da mesma classe podem chamar um método privado. Nenhum deles pode acessar subclasses privadas na classe pai.

a classe pode acessar membros privados. Veja o Exemplo 6.8, o método equals compara dois widgets O operador == compara dois widgets da mesma classe, mas neste exemplo cada instância do objeto tem um ID exclusivo.

preço

. Observe como o método equals acessa a propriedade privada de outra instância do Widget. Java e C permitem esta operação.

classWidget
{
privado $nome;
preço privado $;
private $id;

função pública __construct($nome, $preço)
{
$este->nome = $nome;
$este->preço = floatval($preço);
$this->id = uniqid();
}
//verifica se dois widgets são iguais Verifica se dois widgets são iguais
função pública é igual($widget)
{
return(($this->nome == $widget->nome)AND
($este->preço == $widget->preço));
}
}
$w1 = novo Widget('Cog', 5,00);
$w2 = novo Widget('Cog', 5,00);

7.00

);

if($w1->é igual a($w2))
{
print("w1 e w2 são iguaisn");
}

//FALSO
if($w1->é igual a($w3))
{
print("w1 e w3 são iguaisn");
}

//FALSE, == inclui id na comparação
if($w1 == $w2) //diferente porque os IDs são diferentes
{
print("w1 e w2 são iguaisn");
}
?>

Se você é novo na programação orientada a objetos, pode estar se perguntando qual é o propósito de usar membros privados. Você deve se lembrar das ideias de encapsulamento e acoplamento, que discutimos no início deste capítulo.

as

propriedades internas, então não haverá um relacionamento implícito.

propriedades privadas ainda podem ser compartilhadas por código externo. A solução é usar um par de métodos públicos, um é get (obter o valor da propriedade), o outro é set (definir o valor da propriedade). valor inicial. Isso permite que a comunicação entre os membros ocorra por meio de uma interface estreita e bem qualificada. Isso também oferece a oportunidade de alterar o valor passado para o método. Observe no Exemplo 6.8 como o construtor força o preço a ser um número flutuante (floadval(). ))

Membros protegidos podem ser acessados ​​por todos os métodos da mesma classe e em classes herdadas violam o espírito do encapsulamento porque permitem que subclasses dependam de Escrever um atributo específico no método protegido não traz essa preocupação. usar o método protegido precisa ser claro sobre a estrutura de sua classe pai.

Observe que o Widget agora tem um método protegido chamado getName. Se uma instância do Widget tentar chamar o método protegido, ocorrerá um erro: $w1->getName(. ) gera um erro, mas o método getName na subclasse Thing pode chamar esse método protegido. É claro que, para provar que o método Widget::getName está protegido, este exemplo parece muito simples. compreender a estrutura interna do objeto.

<?php
classWidget
{
privado $nome;
preço privado $;
private $id;

função pública __construct($nome, $preço)
{
$este->nome = $nome;
$este->preço = floatval($preço);
$this->id = uniqid();
}

//verifica se dois widgets são iguais
função pública é igual($widget)
{
return(($this->nome == $widget->nome)AND
($este->preço == $widget->preço));
}

função protegida getName()
{
return($este->nome);
}
}

classe Thing estende Widget
{
private $cor;

função pública setColor($cor)
{
$this->cor = $cor;
}

função pública getColor()
{
return($this->cor);
}

função pública getNome()
{
return(parent::getNome());
}
}

$w1 = novo Widget('Cog', 5.00);
$w2 = nova Coisa('Cog', 5,00);
$w2->setColor('Yellow');

//TRUE (ainda!) O resultado ainda é verdadeiro
if($w1->é igual a($w2))
{
print("w1 e w2 são iguaisn");
}

//imprime a saída do Cog Cog
print($w2->getNome());
?>

Uma subclasse pode alterar a forma como o método é acessado substituindo o método da classe pai. No entanto, ainda existem algumas restrições. Se você substituir um membro da classe pública, ele deverá permanecer público na subclasse. membro, ele pode permanecer protegido ou se tornar público. Membros privados ainda serão visíveis apenas na classe atual. Portanto, tecnicamente, você não pode substituir um membro privado.

A palavra-chave Final é outra maneira de restringir o acesso aos métodos de membro. Uma subclasse não pode substituir um método marcado como final em uma classe pai.