O método de acesso do PHP5 permite restringir o acesso aos membros da classe. Este é um recurso novo no PHP5, mas já existe há muito tempo em muitas linguagens orientadas a objetos. Com métodos de acesso, você pode desenvolver um aplicativo confiável orientado a objetos e construir uma biblioteca de classes reutilizável orientada a objetos.
Assim como C++ e Java, o PHP possui três métodos de acesso: público, privado e protegido. O método de acesso para um membro da classe pode ser um deles. Se você não especificar o método de acesso, o método de acesso padrão também será público. Membros estáticos especificam um método de acesso. Coloque o método de acesso antes da palavra-chave estática (como membros públicos estáticos).
Qualquer código fora da classe pode ler e escrever propriedades públicas. o script. Chame um método público em qualquer lugar. 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.
Membros privados só são visíveis dentro da classe. Você não pode alterar ou ler o valor de uma propriedade privada fora do método de classe onde ela reside. Da mesma forma, apenas métodos na mesma classe podem chamar um método privado, e subclasses herdadas não podem acessar membros privados na classe pai.
Observe que os membros privados podem ser acessados por qualquer membro da classe e por instâncias da classe. Observando o Exemplo 6.8, o método equals compara dois widgets. O operador == compara dois objetos da mesma classe, mas neste exemplo cada instância do objeto possui um ID exclusivo. O método equals compara apenas nome e preço. Observe como o método equals acessa a propriedade privada de outra instância do Widget. Tanto Java quanto C permitem isso.
Listagem 6.8
Widget de classe
de membros privados
{
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 public function equals($widget)
{
return(($this->nome == $widget->nome)AND ($this->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 iguais n");
}
//FALSO
if($w1->é igual a($w3))
{
print("w1 e w3 são iguais n");
}
//FALSE, == inclui id na comparação
if($w1 == $w2) //diferente porque os IDs são diferentes
{
print("w1 e w2 são iguais n");
}
?＞
Se você é novo na programação orientada a objetos, você pode estar se perguntando qual é o propósito de usar membros privados. Você pode se lembrar das ideias de encapsulamento e acoplamento, que discutimos no início deste capítulo. Os membros privados ajudam a encapsular os dados. Eles podem ser ocultados dentro de uma classe para não serem acessados por código fora da classe. Eles também ajudam a obter um acoplamento fraco. Se o código fora da estrutura de dados não puder acessar diretamente as propriedades internas, não haverá correlação implícita.
Claro, a maioria das propriedades privadas ainda pode ser compartilhada 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). Os construtores também aceitam valores iniciais para propriedades. 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 os valores passados para o método. Faça do preço um número flutuante (floadval()).
Membros protegidos (protegidos) podem ser acessados por todos os métodos da mesma classe e por todos os métodos das classes herdadas. Propriedades públicas vão contra o espírito do encapsulamento porque permitem que subclasses dependam de uma propriedade específica para escrever. Métodos protegidos não trazem essa preocupação. Uma subclasse que usa um método protegido precisa estar muito consciente da estrutura de sua classe pai. .
O Exemplo 6.9 é melhorado em relação ao Exemplo 6.8 e inclui uma subclasse Thing de Widget. 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 isso de protected. Obviamente, este exemplo é muito simples para provar que o método Widget::getName está protegido. Em situações reais, o uso do método protegido depende da compreensão da estrutura interna do objeto.
Listagem 6.9
Widget de classe
de membros protegidos
{
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($this->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 iguais n");
}
//imprime a saída do Cog Cog
print($w2->getNome());
?>
Uma subclasse pode alterar o método de acesso ao método 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 em suas subclasses. Se você substituir um membro protegido, ele poderá permanecer protegido ou tornar-se público. Declarar um membro com o mesmo nome de um membro privado da classe pai simplesmente criará um membro diferente na classe atual. Portanto, tecnicamente você não pode substituir um membro privado.
A palavra-chave Final é outra forma de restringir o acesso aos métodos membros. As subclasses não podem substituir métodos marcados como finais na classe pai e a palavra-chave Final não pode ser usada para atributos.