Orientação a Objetos é um paradigma de programação que organiza o código em torno de "objetos", que são instâncias de "classes". Esses objetos podem ter propriedades (dados) e métodos (funções) que definem seu comportamento.

Classes
Uma classe é como um "molde" ou "plano" que define as características e comportamentos de um objeto. Ela descreve os atributos (dados) e os métodos (ações) que os objetos dessa classe terão.

Pense em uma classe como a descrição de um tipo de objeto. Ela define o que o objeto pode fazer (métodos) e o que o objeto possui (propriedades/atributos), mas não cria o objeto em si.

Objetos
Um objeto é uma instância de uma classe. Ele é criado a partir da classe e representa uma entidade individual com os valores dos atributos definidos e a capacidade de executar os métodos especificados na classe.

Pense em um objeto como uma realização concreta da classe. Enquanto a classe é o plano, o objeto é o produto final criado a partir desse plano.

Exemplo de Classe e Objeto

<?php

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

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

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

// Atribuindo as propriedades do objeto
$meuCarro->cor = "Vermelho";
$meuCarro->modelo = "Fusca";

// Usando um método
echo $meuCarro->ligar(); // Saída: O carro está ligado!

Herança
A herança é um dos princípios fundamentais da Programação Orientada a Objetos (OOP) e permite que uma classe herde propriedades e métodos de outra classe. Em termos simples, herança possibilita a criação de uma nova classe (chamada de subclasse ou classe filha) que reutiliza, estende ou modifica o comportamento de uma classe existente (chamada de superclasse ou classe pai).

<?php 

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

    public function dirigir() {
        echo "O veículo 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() {
        echo "Abrindo uma porta do carro.";
    }

    // Sobrescrevendo um método da classe pai
    public function dirigir() {
        echo "O carro está sendo dirigido.";
    }
}

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

// Acessando métodos da classe pai e da classe filha
$meuCarro->dirigir();     // Exibe "O carro está sendo dirigido."
$meuCarro->abrirPorta();  // Exibe "Abrindo uma porta do carro."

Encapsulamento
Prática de esconder os detalhes internos de um objeto e expor apenas o que é necessário para a interação com ele. Em outras palavras, encapsulamento permite que você controle como os dados de um objeto são acessados e modificados, protegendo-os de interferências externas indevidas.

Isso é feito através de modificadores de acesso (como public, private e protected) para determinar quais partes de um objeto podem ser acessadas de fora da classe.

public: Propriedades e métodos podem ser acessados de qualquer lugar.
private: Propriedades e métodos só podem ser acessados de dentro da própria classe.
protected: Propriedades e métodos podem ser acessados dentro da própria classe e em subclasses.

<?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;
        }
    }

    // Método público para visualizar o saldo
    public function obterSaldo() {
        return $this->saldo;
    }

    // Método privado, acessível apenas dentro da classe
    private function aplicarTaxa() {
        $this->saldo -= 5; // Taxa de manutenção
    }
}

$conta = new ContaBancaria(100);
$conta->depositar(50);
echo $conta->obterSaldo(); // Exibe 150

Polimorfismo
É um dos princípios fundamentais da Programação Orientada a Objetos (OOP) e refere-se à capacidade de diferentes classes utilizarem métodos com o mesmo nome, mas comportamentos distintos. Em outras palavras, o polimorfismo permite que o mesmo método seja implementado de formas diferentes em classes diferentes.

O termo polimorfismo vem do grego e significa "muitas formas", indicando que um único nome de método pode funcionar de maneira diferente dependendo do objeto que o invoca.

<?php

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

// Classes filhas que sobrescrevem o método emitirSom
class Cachorro extends Animal {
    public function emitirSom() {
        echo "O cachorro late.";
    }
}

class Gato extends Animal {
    public function emitirSom() {
        echo "O gato mia.";
    }
}

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

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

// Chamando o método com comportamento polimórfico
fazerAnimalEmitirSom($cachorro);  // Exibe "O cachorro late."
fazerAnimalEmitirSom($gato);      // Exibe "O gato mia."

Você pode executar o código em https://onecompiler.com/php

Programação Orientada a Objetos em PHP