Entendendo a Programação Orientada a Objetos em PHP

Programação Orientada a Objetos (POO) é uma forma de estruturar código em torno de objetos — unidades independentes que agrupam dados (chamados de propriedades) e o comportamento que age sobre esses dados (chamados de métodos). Em vez de escrever uma longa lista de funções que passam dados entre si, você modela as entidades do seu domínio de problema (um usuário, um pedido, uma conexão de banco de dados) como objetos e deixa que eles gerenciem seu próprio estado.

PHP suporta POO desde o PHP 5, e frameworks PHP modernos como Laravel e Symfony são construídos quase inteiramente sobre ela. Este capítulo explica o que é POO, por que ela existe e como os conceitos fundamentais se mapeiam para a sintaxe PHP. Ao final, você saberá a diferença entre uma classe e um objeto e reconhecerá os quatro pilares da POO: encapsulamento, herança, polimorfismo e abstração.

PHP procedural vs. orientado a objetos

Antes das classes, o código PHP era tipicamente procedural — uma sequência de instruções e funções operando sobre variáveis simples:

$carMake = "Ford";
$carModel = "Mustang";

function describeCar($make, $model) {
  return "The car is a $make $model.";
}

echo describeCar($carMake, $carModel);
// The car is a Ford Mustang.

Isso funciona, mas os dados ($carMake, $carModel) e a função que os utiliza estão conectados de forma fraca. À medida que um projeto cresce, fica difícil rastrear quais funções pertencem a quais dados. A POO resolve isso empacotando os dados e o comportamento juntos em uma única classe.

Classes e objetos

Os dois conceitos fundamentais da POO são a classe e o objeto:

• Uma classe é um modelo. Ela descreve quais propriedades e métodos um objeto terá, mas não é um valor que você pode usar diretamente — como uma planta arquitetônica para uma casa.
• Um objeto é uma instância concreta criada a partir desse modelo, com valores reais preenchidos — como uma casa real construída a partir da planta.

Em PHP, você declara uma classe com a palavra-chave class e cria um objeto a partir dela com o operador new:

class Car {
  public $make;
  public $model;
}

$car = new Car();   // $car is an object (an instance of Car)
$car->make = "Ford";
$car->model = "Mustang";

echo $car->make;    // Ford

Você pode criar quantos objetos independentes quiser a partir de uma classe, e cada um mantém sua própria cópia das propriedades. O operador de seta -> acessa uma propriedade ou método em um objeto. Saiba mais em Classes e Objetos PHP.

Os quatro pilares da POO

A POO é construída sobre quatro princípios fundamentais. O PHP oferece um recurso de linguagem dedicado para cada um.

Encapsulamento

Encapsulamento significa manter os dados de um objeto e os métodos que os alteram juntos, e controlar o acesso a partir do exterior. Ao marcar propriedades como private e expô-las apenas por meio de métodos, você protege um objeto de ser colocado em um estado inválido.

class BankAccount {
  private $balance = 0;

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

  public function getBalance() {
    return $this->balance;
  }
}

$account = new BankAccount();
$account->deposit(100);
echo $account->getBalance();   // 100

Aqui $balance não pode ser definido diretamente com um valor sem sentido — toda alteração passa por deposit(), que valida a entrada.

Herança

Herança permite que uma classe reutilize as propriedades e métodos de outra. Uma classe filha declarada com extends ganha automaticamente tudo do seu pai e pode adicionar ou substituir. Isso evita duplicar código compartilhado. Veja Herança PHP para mais detalhes.

class Vehicle {
  public function start() {
    return "Engine started.";
  }
}

class Car extends Vehicle {
  public function openTrunk() {
    return "Trunk opened.";
  }
}

$car = new Car();
echo $car->start();        // Engine started.  (inherited)
echo $car->openTrunk();    // Trunk opened.     (its own)

Polimorfismo

Polimorfismo ("muitas formas") significa que classes diferentes podem responder à mesma chamada de método à sua própria maneira. O código que chama makeSound() não precisa saber se está lidando com um Dog ou um Cat:

class Dog {
  public function makeSound() { return "Woof"; }
}

class Cat {
  public function makeSound() { return "Meow"; }
}

foreach ([new Dog(), new Cat()] as $animal) {
  echo $animal->makeSound() . "\n";
}
// Woof
// Meow

Isso é mais poderoso quando combinado com interfaces, que garantem que toda classe forneça o mesmo conjunto de métodos.

Abstração

Abstração significa ocultar detalhes de implementação por trás de uma interface simples e bem definida. Os usuários de uma classe trabalham com o que ela faz, não como ela faz. PHP suporta isso por meio de classes abstratas e interfaces, que definem assinaturas de métodos sem implementação (ou com implementação parcial).

Juntando tudo: um exemplo completo

A classe abaixo combina propriedades, um construtor que é executado automaticamente quando o objeto é criado, e um método:

class Car {
  public $color;
  public $make;
  public $model;

  function __construct($color, $make, $model) {
    $this->color = $color;
    $this->make  = $make;
    $this->model = $model;
  }

  function getDescription() {
    return "The car is a " . $this->make . " " . $this->model . " in " . $this->color . " color.";
  }
}

$car = new Car("red", "Ford", "Mustang");
echo $car->getDescription();
// The car is a Ford Mustang in red color.

O que acontece aqui:

• A classe Car declara três propriedades públicas — color, make e model.
• __construct() é um método especial que o PHP chama no momento em que new Car(...) é executado. Ele copia os argumentos para as propriedades do objeto usando $this, que sempre se refere ao objeto atual.
• getDescription() lê essas propriedades e retorna uma frase.
• new Car("red", "Ford", "Mustang") constrói o objeto; chamar $car->getDescription() produz a saída mostrada no comentário.

Quando você deve usar POO?

A POO brilha quando uma aplicação tem muitos conceitos relacionados com seus próprios dados e comportamento, quando você quer reutilizar código em um projeto, ou quando trabalha com um framework que a espera. Para um pequeno script pontual, funções procedurais simples podem ser mais simples. A maior parte do PHP real — APIs, aplicações web, bibliotecas — apoia-se na POO porque ela mantém bases de código crescentes organizadas e testáveis.

Conclusão

A programação orientada a objetos organiza o código em torno de objetos que agrupam dados com comportamento. Você define uma classe como modelo e cria objetos a partir dela com new. Os quatro pilares — encapsulamento, herança, polimorfismo e abstração — fornecem ferramentas para proteger dados, reutilizar código e manter grandes aplicações gerenciáveis.

Para se aprofundar, continue com Classes e Objetos PHP, depois explore herança, interfaces, classes abstratas e traits.

Prática