Público, Protegido, Privado

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy — lição 38 de 91.

Bem-vindo ao capítulo de Encapsulamento! Encapsulamento trata-se de controlar o acesso aos dados internos da sua classe. O PHP fornece três modificadores de acesso que determinam de onde as propriedades e métodos podem ser acessados: public, protected e private.

Veja como cada modificador funciona:

<?php
class BankAccount {
    public $accountHolder;    // Acessível de qualquer lugar
    protected $accountNumber; // Acessível nesta classe e em classes filhas
    private $balance;         // Acessível apenas nesta classe
    
    public function __construct($holder, $number, $balance) {
        $this->accountHolder = $holder;
        $this->accountNumber = $number;
        $this->balance = $balance;
    }
    
    public function getBalance() {
        return $this->balance;
    }
}

$account = new BankAccount("John", "12345", 1000);

echo $account->accountHolder . "\n";  // Funciona - público
echo $account->getBalance();          // Funciona - método público

Saída:

John
1000

Tentar acessar $account->balance diretamente causaria um erro porque é privado. O mesmo se aplica a $account->accountNumber de fora da hierarquia de classes. Essa proteção garante que dados sensíveis só possam ser modificados através de métodos controlados.

Modificador	Mesma Classe	Classe Filha	Fora
`public`	Sim	Sim	Sim
`protected`	Sim	Sim	Não
`private`	Sim	Não	Não

Ponto Chave: Use private para dados internos que não devem ser acessados diretamente, protected para dados que as classes filhas precisam, e public apenas para acesso externo seguro.

Desafio

Fácil

Vamos construir um sistema seguro de gerenciamento de funcionários que demonstra como os modificadores de acesso protegem dados sensíveis. Você criará uma hierarquia de classes onde diferentes níveis de informação são acessíveis dependendo de onde o código está sendo executado — dentro da classe, em uma classe filha ou de fora.

Você organizará seu código em três arquivos:

Employee.php — Crie uma classe Employee que gerencie os dados do funcionário com níveis de visibilidade apropriados. A classe deve ter:
- Uma propriedade public $name para o nome do funcionário (seguro para qualquer um ver)
- Uma propriedade protected $employeeId para o ID interno (necessário para classes filhas)
- Uma propriedade private $salary para informações salariais sensíveis (apenas esta classe deve acessá-la diretamente)
O construtor deve aceitar todos os três valores e atribuí-los. Adicione um método público getSalary() que retorna o salário privado — esta é a maneira controlada de acessar dados protegidos. Adicione também um método público getPublicInfo() que retorna "[name] works here".
Manager.php — Crie uma classe Manager que estenda Employee. Inclua o arquivo Employee. O construtor deve aceitar name, employeeId, salary e um nome de departamento. Chame o construtor pai com os três primeiros valores e, em seguida, armazene o departamento em uma propriedade privada. Adicione um método público getTeamInfo() que retorna "Manager [name] (ID: [employeeId]) leads [department]". Observe como a classe filha pode acessar o $employeeId protegido, mas precisaria de getSalary() para acessar o salário privado.
main.php — Inclua o arquivo Manager. Você receberá quatro entradas: um nome, um ID de funcionário, um salário (como uma string que você converterá para um inteiro) e um nome de departamento. Crie uma instância de Manager com esses valores. Imprima três linhas:
- O nome do gerente acessado diretamente (propriedade pública)
- O resultado da chamada de getTeamInfo()
- O resultado da chamada de getSalary()

Este desafio mostra o encapsulamento em ação: o nome é livremente acessível, o ID do funcionário é compartilhado com as classes filhas através da visibilidade protegida e o salário permanece trancado na classe pai — acessível apenas através de um método público controlado.

Folha de consulta

O PHP fornece três modificadores de acesso para controlar onde propriedades e métodos podem ser acessados:

Modificador	Mesma Classe	Classe Filha	Fora
`public`	Sim	Sim	Sim
`protected`	Sim	Sim	Não
`private`	Sim	Não	Não

Exemplo:

<?php
class BankAccount {
    public $accountHolder;    // Acessível de qualquer lugar
    protected $accountNumber; // Acessível nesta classe e em classes filhas
    private $balance;         // Acessível apenas nesta classe
    
    public function __construct($holder, $number, $balance) {
        $this->accountHolder = $holder;
        $this->accountNumber = $number;
        $this->balance = $balance;
    }
    
    public function getBalance() {
        return $this->balance;
    }
}

$account = new BankAccount("John", "12345", 1000);
echo $account->accountHolder;  // Funciona - public
echo $account->getBalance();   // Funciona - método public

Melhores Práticas:

Use private para dados internos que não devem ser acessados diretamente
Use protected para dados que as classes filhas precisam
Use public apenas para acesso externo seguro

Experimente você mesmo

<?php
require_once 'Manager.php';

// Ler entradas
$name = trim(fgets(STDIN));
$employeeId = trim(fgets(STDIN));
$salary = intval(trim(fgets(STDIN)));
$department = trim(fgets(STDIN));

// TODO: Criar uma instância de Manager com os valores de entrada

// TODO: Imprimir o nome do gerente (acessado diretamente como propriedade pública)

// TODO: Imprimir o resultado da chamada de getTeamInfo()

// TODO: Imprimir o resultado da chamada de getSalary()
?>