PHP Orientado a Objetos: Uma Introdução

Programação Orientada a Objetos (POO)

A Programação Orientada a Objetos (POO) é um paradigma de programação que organiza o código em torno de "objetos", que são instâncias de "classes". Esses objetos combinam dados (propriedades ou atributos) e comportamentos (métodos ou funções), promovendo modularidade, reutilização de código e facilidade de manutenção.

Este artigo explora os conceitos fundamentais da POO — Classes, Objetos, Herança, Encapsulamento e Polimorfismo — com exemplos práticos em PHP.

---

Classes

Uma classe é um modelo ou blueprint que define as propriedades (dados) e métodos (comportamentos) de um objeto. Ela funciona como um molde, especificando o que um objeto pode fazer e quais dados ele armazena, sem criar o objeto em si. Por exemplo, uma classe Carro pode definir atributos como cor e modelo, além de métodos como ligar().

---

Objetos

Um objeto é uma instância de uma classe, ou seja, um elemento concreto criado a partir do molde da classe. Cada objeto possui valores específicos para os atributos definidos na classe e pode executar os métodos associados. Por exemplo, um objeto da classe Carro pode ter cor = "Vermelho" e modelo = "Fusca".

Exemplo de Classe e Objeto

<?php

// Definindo uma classe
class Carro {
    // Propriedades
    public $cor;
    public $modelo;

    // Método
    public function ligar() {
        return "O carro {$this->modelo} está ligado!";
    }
}

// Criando um objeto
$meuCarro = new Carro();

// Atribuindo valores às propriedades
$meuCarro->cor = "Vermelho";
$meuCarro->modelo = "Fusca";

// Executando o método
echo $meuCarro->ligar() . PHP_EOL; // Saída: O carro Fusca está ligado!

?>

---

Herança

A herança permite que uma classe (subclasse ou classe filha) herde propriedades e métodos de outra classe (superclasse ou classe pai). Isso promove reutilização de código e a criação de hierarquias de classes, onde a subclasse pode estender ou modificar o comportamento da superclasse. Por exemplo, uma classe Carro pode herdar de uma classe Veiculo, adicionando funcionalidades específicas.

Exemplo de Herança

<?php

// Classe pai (superclasse)
class Veiculo {
    public $marca;
    public $modelo;

    public function dirigir() {
        return "O veículo {$this->modelo} está sendo dirigido.";
    }
}

// Classe filha (subclasse) que herda de Veiculo
class Carro extends Veiculo {
    public $numeroDePortas;

    // Método específico da classe filha
    public function abrirPorta() {
        return "Abrindo uma porta do carro com {$this->numeroDePortas} portas.";
    }

    // Sobrescrevendo o método da classe pai
    public function dirigir() {
        return "O carro {$this->modelo} está sendo dirigido com estilo!";
    }
}

// Criando um objeto da classe filha
$meuCarro = new Carro();
$meuCarro->marca = "Toyota";
$meuCarro->modelo = "Corolla";
$meuCarro->numeroDePortas = 4;

// Acessando métodos
echo $meuCarro->dirigir() . PHP_EOL;    // Saída: O carro Corolla está sendo dirigido com estilo!
echo $meuCarro->abrirPorta() . PHP_EOL; // Saída: Abrindo uma porta do carro com 4 portas.

?>

---

Encapsulamento

O encapsulamento é a prática de proteger os dados internos de um objeto, controlando o acesso a eles por meio de modificadores de acesso (public, private, protected). Isso garante que os dados sejam manipulados apenas de maneira controlada, protegendo a integridade do objeto.

• public: Acessível de qualquer lugar.
• private: Acessível apenas dentro da própria classe.
• protected: Acessível dentro da classe e em suas subclasses.

Exemplo de Encapsulamento

<?php

class ContaBancaria {
    private $saldo;

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

    // Método público para depositar
    public function depositar($quantia) {
        if ($quantia > 0) {
            $this->saldo += $quantia;
            $this->aplicarTaxa();
            return "Depósito de R$ $quantia realizado com sucesso.";
        }
        return "Quantia inválida para depósito.";
    }

    // Método público para consultar o saldo
    public function obterSaldo() {
        return "Saldo atual: R$ {$this->saldo}";
    }

    // Método privado para aplicar taxa
    private function aplicarTaxa() {
        $this->saldo -= 5; // Taxa de manutenção
    }
}

// Criando um objeto
$conta = new ContaBancaria(100);
echo $conta->depositar(50) . PHP_EOL; // Saída: Depósito de R$ 50 realizado com sucesso.
echo $conta->obterSaldo() . PHP_EOL;  // Saída: Saldo atual: R$ 145

?>

---

Polimorfismo

O polimorfismo permite que diferentes classes implementem métodos com o mesmo nome, mas com comportamentos distintos. Isso possibilita que objetos de classes diferentes sejam tratados de forma uniforme, chamando o mesmo método, mas obtendo resultados específicos de cada classe. O termo "polimorfismo" significa "muitas formas", refletindo a flexibilidade desse conceito.

Exemplo de Polimorfismo

<?php

// Classe pai
class Animal {
    public function emitirSom() {
        return "O animal faz um som genérico.";
    }
}

// Classes filhas que sobrescrevem o método emitirSom
class Cachorro extends Animal {
    public function emitirSom() {
        return "O cachorro late: Au au!";
    }
}

class Gato extends Animal {
    public function emitirSom() {
        return "O gato mia: Miau!";
    }
}

// Função que demonstra polimorfismo
function fazerAnimalEmitirSom(Animal $animal) {
    return $animal->emitirSom();
}

// Criando objetos
$cachorro = new Cachorro();
$gato = new Gato();

// Demonstrando polimorfismo
echo fazerAnimalEmitirSom($cachorro) . PHP_EOL; // Saída: O cachorro late: Au au!
echo fazerAnimalEmitirSom($gato) . PHP_EOL;     // Saída: O gato mia: Miau!

?>

---

A Programação Orientada a Objetos é um paradigma poderoso que organiza o código de forma modular e reutilizável. Com classes e objetos, você define estruturas de dados e comportamentos; com herança, reutiliza e estende funcionalidades; com encapsulamento, protege dados sensíveis; e com polimorfismo, garante flexibilidade e comportamentos específicos.

Você pode testar os códigos apresentados em plataformas como OneCompiler.