Introdução à Programação Orientada a Objetos (POO)

O que é Programação Orientada a Objetos?

A Programação Orientada a Objetos (POO) é um dos paradigmas mais utilizados no desenvolvimento de software moderno. Ela organiza o código de forma mais intuitiva e reutilizável, facilitando a manutenção e o crescimento de seus projetos.

O que é uma Classe?

Uma classe é um modelo ou estrutura que define atributos (dados) e métodos (comportamentos). Podemos pensar nela como um molde para criar objetos.

Exemplo de classe em PHP:

<?php

class Carro {
    // Atributos
    private $marca;
    private $modelo;

    // Método construtor
    public function __construct($marca, $modelo) {
        $this->marca = $marca;
        $this->modelo = $modelo;
    }

    // Método
    public function acelerar() {
        echo "O {$this->marca} {$this->modelo} está acelerando!<br>";
    }
}

?>

A classe Carro define que todo carro tem uma marca, um modelo e a capacidade de acelerar.

O que é um Objeto?

Um objeto é uma instância de uma classe. Ele herda os atributos e métodos definidos na classe.

Criando um objeto a partir da classe Carro:

<?php

// Criando um objeto da classe Carro
$meuCarro = new Carro("Toyota", "Corolla");

// Chamando o método acelerar do objeto
$meuCarro->acelerar();  // Saída: O Toyota Corolla está acelerando!

?>

Aqui, $meuCarro é um objeto da classe Carro, com atributos “Toyota” e “Corolla”.

Os 4 Pilares da POO

A POO se baseia em quatro princípios fundamentais, que ajudam a organizar o código de forma mais eficiente e flexível.

1️⃣ Abstração 🎭

A abstração oculta detalhes internos e expõe apenas o necessário para o usuário. Isso torna o código mais limpo e fácil de usar.

// Classe abstrata
abstract class Veiculo {
    // Método abstrato: as classes filhas devem implementar esse método
    abstract public function acelerar();
}

// Classe Carro que herda de Veiculo
class Carro extends Veiculo {
    public function acelerar() {
        return "O carro está acelerando!";
    }
}

// Classe Moto que herda de Veiculo
class Moto extends Veiculo {
    public function acelerar() {
        return "A moto está acelerando!";
    }
}

$carro = new Carro();
$moto = new Moto();

echo $carro->acelerar(); // Saída: O carro está acelerando!<br>
echo $moto->acelerar(); // Saída: A moto está acelerando!

A classe Veiculo é abstrata, ou seja, não pode ser instanciada diretamente. Ela apenas define um contrato (o método acelerar()) que deve ser implementado pelas classes filhas.

As classes Carro e Moto implementam o método acelerar() de maneiras diferentes, mas ambas são tratadas de forma genérica como Veiculo.

Por que é abstração?

O usuário (programador) não precisa saber como o carro ou a moto acelera internamente. Ele só precisa interagir com a classe Veiculo e chamar o método Acelerar(), sem se preocupar com os detalhes de implementação.

2️⃣ Encapsulamento 🛡️

O encapsulamento protege os dados internos de um objeto, permitindo que apenas métodos específicos tenham acesso a eles. Isso evita modificações indesejadas e melhora a segurança do código.

class ContaBancaria {
    public $titular; // Público: pode ser acessado diretamente
    protected $saldo; // Protegido: só pode ser acessado dentro da classe ou por herança
    private $historico = []; // Privado: acessível apenas dentro da classe

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

    public function verSaldo() {
        return "Saldo: R$ " . number_format($this->saldo, 2, ',', '.');
    }

    private function adicionarAoHistorico($mensagem) {
        $this->historico[] = $mensagem;
    }
}

✅ Público (public) → Pode ser acessado de qualquer lugar (ex: $conta->titular).
✅ Protegido (protected) → Só pode ser acessado dentro da classe e por herança (ex: $saldo).
✅ Privado (private) → Só pode ser acessado dentro da própria classe (ex: $historico).

3️⃣ Herança 🏛️

A herança permite que uma classe filha reutilize atributos e métodos de uma classe pai, evitando código duplicado.

<?php

class Veiculo {
    public $marca;

    // Construtor para inicializar a marca do veículo
    public function __construct($marca) {
        $this->marca = $marca; // Atributo marca
    }

    // Método para ligar o veículo
    public function ligar() {
        return "Veículo ligado!";
    }
}

// Carro estende Veiculo e tem um atributo adicional 'modelo'
class Carro extends Veiculo {
    public $modelo;

    // Construtor para inicializar marca e modelo
    public function __construct($marca, $modelo) {
        parent::__construct($marca);    // Chama o construtor da classe pai (Veiculo)
        $this->modelo = $modelo;    // Define o modelo do carro
    }
}

$meuCarro = new Carro("Ford", "Fiesta");
echo $meuCarro->ligar(); // Saída: Veículo ligado!

Aqui, Carro herda de Veículo e reutiliza o método ligar().

4️⃣ Polimorfismo 🔄

O polimorfismo permite que um mesmo método tenha comportamentos diferentes dependendo da classe que o implementa.

<?php

// Define um método genérico 'fazerSom()' que pode ser sobrescrito pelas classes filhas.
class Animal {
    public function fazerSom() {
        return "Som genérico...";
    }
}

// Sobrescreve o método 'fazerSom()' para fornecer um som específico para o cachorro
class Cachorro extends Animal {

    public function fazerSom() {
        return "Au Au!";
    }
}

// Sobrescreve o método 'fazerSom()' para fornecer um som específico para o gato
class Gato extends Animal {
    public function fazerSom() {
        return "Miau!";
    }
}

$pet1 = new Cachorro(); // Criando um objeto do tipo Cachorro
$pet2 = new Gato(); // Criando um objeto do tipo Gato

echo $pet1->fazerSom(); // Saída: Au Au!
echo "<br>";
echo $pet2->fazerSom(); // Saída: Miau!

Aqui, cada classe redefine o método fazersom(), tornando-o específico para cada animal.

Conclusão

A Programação Orientada a Objetos torna o desenvolvimento mais organizado, reutilizável e escalável.

Com os conceitos de classe, objeto, herança, encapsulamento, polimorfismo e abstração, conseguimos estruturar melhor nossos sistemas.