Construtores em PHP
O construtor é um método especial executado automaticamente quando uma instância de uma classe é criada. Em PHP, ele é definido com o método __construct(). Esse método é fundamental para inicializar propriedades e garantir que o objeto comece em um estado válido.
<?php
class Produto {
public $nome;
public $preco;
public $estoque;
public function __construct($nome, $preco, $estoque = 0) {
$this->nome = $nome;
$this->preco = $preco;
$this->estoque = $estoque;
}
public function exibir() {
echo "Produto: {$this->nome} - R$ {$this->preco} (Estoque: {$this->estoque})\n";
}
}
$produto = new Produto("Notebook", 2500.00, 5);
$produto->exibir();
Os construtores podem receber parâmetros, ter valores padrão e executar lógica complexa. Uma prática importante é usar type hints para garantir segurança de tipo. Em PHP 8+, você pode usar promoted properties, tornando o código mais limpo:
<?php
class Cliente {
public function __construct(
public string $nome,
public string $email,
public int $idade = 18
) {}
public function info(): void {
echo "{$this->nome} ({$this->email}) - {$this->idade} anos\n";
}
}
$cliente = new Cliente("Ana Silva", "ana@email.com", 25);
$cliente->info();
Destrutores em PHP
O destrutor é o oposto do construtor. Ele é invocado automaticamente quando um objeto é destruído (quando sai do escopo ou é explicitamente anulado). Em PHP, é definido com __destruct(). Destrutores são úteis para liberar recursos como conexões de banco de dados, arquivos abertos ou conexões de rede.
<?php
class ConexaoDB {
private $conexao;
public function __construct($host, $usuario, $senha) {
$this->conexao = mysqli_connect($host, $usuario, $senha);
if (!$this->conexao) {
throw new Exception("Erro ao conectar ao banco");
}
echo "Conexão estabelecida\n";
}
public function __destruct() {
if ($this->conexao) {
mysqli_close($this->conexao);
echo "Conexão fechada\n";
}
}
public function query($sql) {
return mysqli_query($this->conexao, $sql);
}
}
{
$db = new ConexaoDB("localhost", "root", "senha");
// Usar $db aqui
} // Destrutor chamado automaticamente ao sair do bloco
Importante: Nem sempre é necessário usar destrutores em PHP. A linguagem gerencia memória automaticamente. Use-os apenas quando precisar explicitamente liberar recursos críticos.
Métodos em PHP
Métodos são funções definidas dentro de uma classe. Eles operam sobre os dados (propriedades) do objeto e podem ser públicos, privados ou protegidos. Além disso, existem métodos estáticos que pertencem à classe, não ao objeto.
Métodos de Instância
<?php
class ContaBancaria {
private float $saldo = 0;
public function depositar(float $valor): void {
if ($valor > 0) {
$this->saldo += $valor;
echo "Depósito de R$ $valor realizado\n";
}
}
public function sacar(float $valor): bool {
if ($valor > 0 && $valor <= $this->saldo) {
$this->saldo -= $valor;
echo "Saque de R$ $valor realizado\n";
return true;
}
echo "Saque não autorizado\n";
return false;
}
public function getSaldo(): float {
return $this->saldo;
}
}
$conta = new ContaBancaria();
$conta->depositar(1000);
$conta->sacar(300);
echo "Saldo: R$ " . $conta->getSaldo() . "\n";
Métodos Estáticos
Métodos estáticos pertencem à classe, não a instâncias. Eles são acessados via :: e não precisam de um objeto criado. São ideais para utilidades e cálculos que não dependem do estado da instância.
<?php
class Calculadora {
public static function somar(float $a, float $b): float {
return $a + $b;
}
public static function multiplicar(float $a, float $b): float {
return $a * $b;
}
public static function ehPositivo(float $numero): bool {
return $numero > 0;
}
}
echo Calculadora::somar(10, 5) . "\n"; // 15
echo Calculadora::multiplicar(4, 3) . "\n"; // 12
var_dump(Calculadora::ehPositivo(-5)); // false
Encapsulamento com Getters e Setters
A visibilidade private protege dados sensíveis. Getters e setters controlam o acesso, permitindo validação:
<?php
class Pessoa {
private string $cpf;
private int $idade;
public function setCpf(string $cpf): void {
if (strlen(preg_replace('/\D/', '', $cpf)) === 11) {
$this->cpf = $cpf;
} else {
throw new Exception("CPF inválido");
}
}
public function getCpf(): string {
return $this->cpf;
}
public function setIdade(int $idade): void {
if ($idade >= 0 && $idade <= 150) {
$this->idade = $idade;
} else {
throw new Exception("Idade inválida");
}
}
public function getIdade(): int {
return $this->idade;
}
}
$pessoa = new Pessoa();
$pessoa->setCpf("123.456.789-10");
$pessoa->setIdade(30);
echo "CPF: " . $pessoa->getCpf() . " - Idade: " . $pessoa->getIdade() . "\n";
Conclusão
Dominando construtores, você garante que objetos sempre nasçam em estado válido. Destrutores devem ser usados estrategicamente para liberar recursos críticos. Métodos são o coração da orientação a objetos: use instância para lógica do objeto, estáticos para utilidades. Combine visibilidade (public/private) com getters/setters para proteger seus dados. Esses três conceitos formam a base sólida da programação orientada a objetos em PHP.