private

A palavra-chave private do PHP

private é um modificador de visibilidade (também chamado de modificador de acesso). Quando você marca uma propriedade ou método como private, ele pode ser lido e chamado apenas de dentro da mesma classe — nunca de fora do objeto e nunca de uma classe filha que a estenda.

Visibilidade é o núcleo do conceito de encapsulamento: permite que uma classe oculte seus dados internos e lógica auxiliar por trás de uma interface pública controlada, de modo que o mundo externo dependa apenas do que você escolhe expor. O PHP possui três níveis de visibilidade:

Esta página abrange a sintaxe de private, por que e quando utilizá-lo, e as armadilhas que costumam pegar as pessoas de surpresa — herança, a regra de "mesma classe, objeto diferente", e o comportamento de erros. Para uma visão mais ampla, consulte Modificadores de Acesso do PHP e Classes e Objetos do PHP.

Sintaxe

Prefixe a declaração da propriedade ou método com a palavra-chave private:

class MyClass {
  private $myPrivateVariable;

  private function myPrivateFunction() {
    // Only code inside MyClass can call this.
  }
}

Um membro private é totalmente utilizável dentro da classe — outros métodos de MyClass podem ler $this->myPrivateVariable e chamar $this->myPrivateFunction() — mas qualquer acesso externo lança um Error.

Exemplos

Vejamos alguns exemplos práticos de como a palavra-chave "private" pode ser utilizada:

Exemplos de private em PHP

<?php

// Example 1
class Person
{
  private $name;

  public function __construct($name)
  {
    $this->name = $name;
  }

  private function getName()
  {
    return $this->name;
  }

  public function greet()
  {
    $name = $this->getName();
    echo "Hello, $name!" . PHP_EOL;
  }
}

$person = new Person("John");
$person->greet(); // Output: Hello, John!

// Example 2
class BankAccount
{
  private $balance = 0;

  public function deposit($amount)
  {
    $this->balance += $amount;
  }

  public function withdraw($amount)
  {
    if ($amount > $this->balance) {
      echo "Insufficient funds!" . PHP_EOL;
    } else {
      $this->balance -= $amount;
      echo "Withdrawal successful!" . PHP_EOL;
    }
  }
}

$account = new BankAccount();
$account->deposit(100);
$account->withdraw(50); // Output: Withdrawal successful!
$account->withdraw(100); // Output: Insufficient funds!

Em ambos os exemplos, $name, getName() e $balance fazem parte da maquinaria interna da classe. O mundo externo só interage com greet(), deposit() e withdraw() — os pontos de entrada seguros e validados. Isso é o encapsulamento em ação: o saldo de BankAccount nunca pode ser negativo porque nada fora da classe pode gravá-lo diretamente.

O que acontece quando você quebra a regra

Acessar um membro privado de fora da classe é um Error fatal, não um null silencioso:

<?php

class Person
{
  private $name = "John";
}

$p = new Person();
echo $p->name;
// PHP Fatal error: Uncaught Error: Cannot access private property Person::$name

Isso é intencional — o erro aparece imediatamente em vez de deixar o código depender silenciosamente de detalhes internos.

Private é por classe, não por objeto

Uma surpresa comum: membros privados são visíveis entre duas instâncias da mesma classe. A fronteira do "private" é a classe, portanto um objeto pode ler os membros privados de outro objeto desde que ambos sejam do mesmo tipo:

<?php

class Money
{
  private $cents;

  public function __construct($cents)
  {
    $this->cents = $cents;
  }

  // Reads $other->cents directly — allowed, same class.
  public function add(Money $other)
  {
    return new Money($this->cents + $other->cents);
  }

  public function format()
  {
    return number_format($this->cents / 100, 2);
  }
}

$total = (new Money(150))->add(new Money(350));
echo $total->format(); // Output: 5.00

Private e herança

Ao contrário de protected, um membro private não é herdado por subclasses. Uma classe filha não pode ver os membros privados do pai e, se declarar um membro com o mesmo nome, obtém sua própria cópia separada:

<?php

class Base
{
  private $value = "base";

  public function show()
  {
    echo $this->value . PHP_EOL;
  }
}

class Child extends Base
{
  private $value = "child";
}

(new Child())->show(); // Output: base

show() foi definido em Base, então ele enxerga o $value privado de Base — o $value do filho é uma propriedade completamente separada. Se você quiser que as subclasses compartilhem e substituam um membro, use protected. Consulte Herança no PHP para mais informações.

Quando usar private

• Estado interno que deve permanecer válido — como o saldo de BankAccount acima. Exponha mutadores (deposit, withdraw) que aplicam as regras.
• Métodos auxiliares que são detalhes de implementação, para que você possa renomeá-los ou reescrevê-los mais tarde sem quebrar quem os chama.
• Comece com o nível mais restritivo. Inicie com private; amplie para protected ou public apenas quando houver uma necessidade real. É muito mais fácil afrouxar a visibilidade do que restringi-la depois que outro código já depende dela.

Benefícios

• Encapsulamento — agrupe dados com os métodos que operam sobre eles e evite que o resto do programa acesse diretamente. Consulte Classes e Objetos do PHP.
• Ocultação de informações — quem chama os métodos depende da sua API pública, não dos seus detalhes internos, então você pode mudar o funcionamento da classe sem quebrá-los.
• Invariantes — como as gravações passam pelos seus métodos, você pode garantir que o objeto esteja sempre em um estado válido.

Resumo

A palavra-chave private restringe um membro de classe à classe que o declara — não às suas subclasses e não ao mundo externo. É a ferramenta padrão para encapsulamento: oculte dados internos e auxiliares, exponha uma pequena API pública validada e mantenha seus objetos em um estado consistente. Use protected quando as subclasses precisarem de acesso, e public apenas para a interface pretendida.

Prática