O PHP é uma linguagem server-side popular para desenvolvmiento web, que oferece suporte a múltiplos paradigmas, incluindo a programação orientada a objetos (POO). A POO é um estilo que utiliza objetos para modelar software, agrupando dados e comportamentos. No PHP, essa abordagem facilita a organização do código, tornando-o modular, reutilizável e de fácil manutenção.

Fundametnos da POO em PHP

Classes e Objetos

Classes servem como moldes para criar objetos, definindo atributos (variáveis) e métodos (funções). Objetos são instâncias concretas dessas classes.

<?php
class Veiculo {
    public $marca = "Genérica";

    public function __construct() {
        echo 'Instância de Veiculo criada.<br>';
    }

    public function __destruct() {
        echo 'Instância de Veiculo destruída.<br>';
    }

    public function acelerar() {
        echo 'Acelerando o veículo.';
    }
}

$carro = new Veiculo();
$carro->acelerar();
?>

Controle de Acesso

Modificadores de acesso controlam a visibilidade dos membros da classe: públicos (acessíveis globalmente), protegidos (acessíveis na classe e subclasses) e privados (acessíveis apenas na própria classe).

<?php
class Conta {
    public $saldoPublico = 100;
    protected $saldoProtegido = 200;
    private $saldoPrivado = 300;

    public function exibirSaldos() {
        echo $this->saldoPublico; // Funciona
        echo $this->saldoProtegido; // Funciona dentro da classe
        echo $this->saldoPrivado; // Funciona dentro da classe
    }
}

$conta = new Conta();
echo $conta->saldoPublico; // Acessível
// echo $conta->saldoProtegido; // Erro fatal
// echo $conta->saldoPrivado; // Erro fatal
$conta->exibirSaldos(); // Exibe todos os saldos
?>

Herança

Herança permite que uma classe filha herde atributos e métodos de uma classe pai, promovendo reutilização de código.

<?php
class Forma {
    public function desenhar() {
        echo 'Desenhando forma genérica.';
    }
}

class Circulo extends Forma {
    // Herda o método desenhar
}

$meuCircle = new Circulo();
$meuCircle->desenhar(); // Saída: Desenhando forma genérica.
?>

Polimorfismo

Polimorfismo permite que diferentes classes implementem uma mesma interface de maneiras distintas, facilitando a extensibilidade.

<?php
interface Pagamento {
    public function processar();
}

class CartaoCredito implements Pagamento {
    public function processar() {
        echo 'Processando pagamento com cartão.';
    }
}

class Boleto implements Pagamento {
    public function processar() {
        echo 'Gerando boleto para pagamento.';
    }
}

$pagamentoCartao = new CartaoCredito();
$pagamentoBoleto = new Boleto();

$pagamentoCartao->processar(); // Saída: Processando pagamento com cartão.
$pagamentoBoleto->processar(); // Saída: Gerando boleto para pagamento.
?>

Construtores e Destrutores

Construtores são executados automaticamente ao instanciar um objeto, enquanto destrutores são chamados quando o objeto é desalocado.

<?php
class Conexao {
    public function __construct() {
        echo 'Conexão estabelecida.<br>';
    }

    public function __destruct() {
        echo 'Conexão encerrada.<br>';
    }
}

$db = new Conexao();
// Ao final do script, o destrutor é chamado.
?>

Recursos Avançados de POO

Métodos e Propriedades Estáticas

Membros estáticos pertencem à classe em si, não a instâncias específicas, e são acessados diretamente via nome da classe.

<?php
class Configuracao {
    public static $versao = '2.0';

    public static function obterVersao() {
        return self::$versao;
    }
}

echo Configuracao::$versao; // Saída: 2.0
echo Configuracao::obterVersao(); // Saída: 2.0
?>

Classes Abstratas e Interfaces

Classes abstratas não podem ser instanciadas e definem métodos que subclasses devem implementar. Interfaces especificam contratos que classes devem seguir, sem implementação.

<?php
abstract class ModeloRelatorio {
    abstract protected function gerarConteudo();

    public function exportar() {
        echo $this->gerarConteudo() . '<br>';
    }
}

class RelatorioVendas extends ModeloRelatorio {
    protected function gerarConteudo() {
        return 'Dados de vendas do mês.';
    }
}

$relatorio = new RelatorioVendas();
$relatorio->exportar(); // Saída: Dados de vendas do mês.
?>

Traits

Traits permitem reutilizar métodos em múltiplas classes sem usar herança, resolvendo problemas de hierarquia limitada.

<?php
trait Logavel {
    public function registrarLog($mensagem) {
        echo "Log: $mensagem<br>";
    }
}

class SistemaAutenticacao {
    use Logavel;

    public function login($usuario) {
        $this->registrarLog("Usuário $usuario autenticado.");
    }
}

$auth = new SistemaAutenticacao();
$auth->login('admin'); // Saída: Log: Usuário admin autenticado.
?>