PHP: Modificadores de acesso

Os modificadores de acesso são elementos de fundamental importância na Programação Orientada a Objetos. Trata-se de palavras reservadas da linguagem de programação que determinam a forma de acesso a atributos e métodos de uma classe.

Neste documento será apresentado como utilizar os modificadores de acesso na linguagem PHP.

Curso relacionado: Curso de PHP Básico

Modificadores de acesso no PHP

Com os modificadores de acesso determinamos a visibilidade de um método ou atributo pertencente a uma classe. Ou seja, definimos se ele pode ou não ser acessado fora da classe em que foi declarado.

Para modificar a visibilidade de um atributo ou método devemos preceder sua declaração de uma das palavras reservadas que representam o modificador, da seguinte forma:

modificador $atributo;
 
modificador function metodo() { }

Os valores possíveis para o modificador são private, protected e public, que serão explicados a seguir.

public

Este é o nível de acesso mais permissivo. Ele indica que o método ou atributo da classe é público, ou seja, pode ser acessado em qualquer outro ponto do código e por outras classes.

No código abaixo podemos ver um exemplo de uso do modificador de acesso public:

class Exemplo {
    public $publico = 'Public';
    public function metodoPublico() { }
}

No código acima foi declarada uma classe denominada Exemplo que possui um atributo público chamado $publico e um método público intitulado metodoPublico(). Neste caso ambos podem ser acessados por qualquer parte do código, incluindo outras classes.

Por exemplo, se criarmos uma instância dessa classe podemos acessar esses dois elementos da seguinte forma:

  $obj = new Exemplo();
  $obj->publico = 'Teste';
  $obj->metodoPublico();

private

Este modificador é o mais restrito. Com ele definimos que somente a própria classe em que um atributo ou método foi declarado pode acessá-lo. Ou seja, nenhuma outra parte do código, nem mesmo as classes filhas, pode acessar esse atributo ou método.

No código abaixo podemos ver um exemplo de uso do modificador de acesso private:

class Exemplo{
 private  $privado = 'Privado';
 private function metodoPrivado() {}
}

Agora, se instanciarmos essa classe e tentarmos acessar esses dois elementos, como no código abaixo, um erro será gerado.

$obj = new Exemplo();
$obj->privado = 'Teste';//Erro
$obj->metodoPrivado();//Erro

protected

Esse modificador indica que somente a própria classe e as classes que herdam dela podem acessar o atributo ou método. Dessa forma, ao instanciar a classe os elementos protegidos (protected) não podem ser acessados diretamente, como ocorre com o public.

A seguir podemos ver um exemplo de uso do modificador de acesso protected:

class Exemplo {
    protected $protegido = 'Protegido';
    protected function metodoProtegido() { }
}

No código acima foi declarada uma classe denominada Exemplo que possui um atributo protegido chamado $protegido e um método protegido intitulado metodoProtegido(). Neste caso ambos só podem ser acessados pela própria classe e pelas suas classes filhas.

Por exemplo, se criarmos uma instância dessa classe não poderemos acessar esses dois elementos desta forma, pois um erro fatal será gerado:

$obj = new Exemplo();
$obj->protegido = 'Teste'; //Erro
$obj->metodoProtegido(); //Erro

Já nas classes filhas, para acessar os elementos protegidos da classe pai é necessário seguir algumas regras:

• Para obter o valor de um atributo protegido da classe pai basta usar $this->atributo;
• Para alterar o valor de um atributo protegido da classe pai é preciso redeclará-lo na classe filha;
• Para chamar um método protegido da classe pai é necessário usar parent::metodo().

Para exemplificar esses aspectos temos no código abaixo uma classe Pai que contém um atributo e um método protegidos. Em seguida temos uma classe Filha, que herda de Pai e acessa os elementos protegidos:

class Pai {
   protected  $protegido = 'Protegido';
   protected function metodoProtegido() {
     echo 'Método protegido na classe pai';
 }
}
class Filha extends Pai {
   public function acessarAtributoProtegido(){
       echo $this->protegido;
   }
   public function chamarMetodoProtegido() {
       parent::metodoProtegido();
   }
}

Linha 10: Nesta linha a classe filha apenas acessa o atributo protegido e imprime seu valor;

Linha 13: Nesta linha a classe filha chama o método protegido da superclasse. Observe o uso da palavra reservada parent, fazendo referência à classe pai.

Nesse exemplo a classe filha apenas leu o valor do atributo. Caso fosse necessário alterar seu valor, seria preciso redeclarar o atributo, assim como foi feito na classe pai:

class Filha extends Pai {
   protected $protegido;
   public function acessarAtributoProtegido(){
       $this->protegido = 'Valor alterado';
       echo $this->protegido;
   }
   public function chamarMetodoProtegido() {
       parent::metodoProtegido();
   }
}

Comparação entre os modificadores

A Tabela 1 lista e compara os níveis de acesso que os modificadores podem proporcionar aos atributos e métodos.

Exemplo prático

A seguir temos um exemplo prático de como declarar atributos e métodos usando os modificadores de acesso em PHP:

class Funcionario{
 public $nome = 'Alex';
 protected  $salario = 200;
 private $rg ='00.000.000-0';
}

Nesse código pode-se observar a declaração de três atributos, cada um com seu respectivo modificador de acesso.

Agora, se instanciarmos a classe Funcionario e tentarmos acessar seus atributos, como consta no código abaixo, podemos analisar o comportamento da linguagem em cada situação:

$funcionario = new Funcionario;
echo $funcionario->nome;
echo $funcionario->salario;
echo $funcionario->rg;

Linha 1: Criamos uma instância da classe Funcionario;

Linha 2: Acessamos o atributo público $nome sem problemas;

Linha 3: Tentamos acessar o atributo protegido $salario, o que gerará um erro;

Linha 4: Novamente será gerado um erro ao tentarmos acessar o atributo privado $rg.