docs: adiciona conteúdos de polimorfismo e encapsulamento

4-Intermediário/10-Encapsulamento.md

@@ -0,0 +1,115 @@
+# 4.6 - Encapsulamento
+
+## O que é?
+
+Encapsulamento é o conceito de **proteger os dados de uma classe**, controlando como eles são acessados e modificados.
+
+ Ou seja:
+Você **esconde os atributos** e permite acesso apenas através de métodos.
+
+---
+
+## Por que usar?
+
+Para garantir que os dados:
+
+* Não sejam alterados de forma errada
+* Tenham regras de validação
+* Fiquem mais seguros
+
+---
+
+## Ideia simples
+
+Pensa em uma conta bancária:
+
+* Você não altera o saldo direto ❌
+* Você usa métodos como `depositar()` ou `sacar()` ✔️
+
+> Isso é encapsulamento.
+
+---
+
+## Exemplo sem encapsulamento (errado)
+
+```php
+<?php
+
+class ContaBancaria {
+    public $saldo = 1000;
+}
+
+$conta = new ContaBancaria();
+$conta->saldo = -5000; // ❌ valor inválido
+```
+
+---
+
+##  Exemplo com encapsulamento (correto)
+
+```php
+<?php
+
+class ContaBancaria {
+
+    private $saldo = 1000;
+
+    public function depositar($valor)
+    {
+        if ($valor > 0) {
+            $this->saldo += $valor;
+        }
+    }
+
+    public function sacar($valor)
+    {
+        if ($valor > 0 && $valor <= $this->saldo) {
+            $this->saldo -= $valor;
+        }
+    }
+
+    public function getSaldo()
+    {
+        return $this->saldo;
+    }
+
+}
+
+$conta = new ContaBancaria();
+$conta->depositar(500);
+$conta->sacar(200);
+
+echo $conta->getSaldo(); // 1300
+```
+
+---
+
+## O que está acontecendo?
+
+* `saldo` é **private** → não pode ser acessado diretamente
+* Só pode ser alterado por métodos controlados
+* Existem regras (`if`) para evitar erros
+
+---
+
+##  Resumão
+
+* Encapsular = **esconder os dados**
+* Acesso só por métodos (getters/setters)
+* Mais segurança e controle
+
+---
+
+## 🧩 Frase pra guardar
+
+> **Encapsulamento é proteger os dados e controlar como eles são acessados.**
+
+---
+
+## 🔗 Relação com outros conceitos
+
+* Usa `private` e `protected` (modificadores de acesso)
+* Trabalha junto com getters e setters
+* Base para código seguro e profissional
+
+---

4-Intermediário/9-Polimorfismo.md

@@ -0,0 +1,171 @@
+# 4.5 - Polimorfismo
+
+## O que é?
+
+Polimorfismo é a capacidade de um mesmo método ter **comportamentos diferentes**, dependendo da classe que o implementa.
+
+> Ou seja:
+Você chama **o mesmo método**, mas o resultado muda.
+
+---
+
+##  Por que usar?
+
+Para evitar vários `if/else` e deixar o código:
+
+* Mais organizado
+* Mais fácil de manter
+* Mais profissional
+
+---
+
+## Ideia simples !
+
+Você tem um método chamado `emitirSom()`:
+
+* Cachorro → **Au au**
+* Gato → **Miau**
+
+> Mesmo método, comportamentos diferentes.
+
+---
+
+##  Exemplo prático
+
+```php
+<?php
+
+class Animal {
+
+    public function emitirSom()
+    {
+        echo "Som genérico";
+    }
+
+}
+
+class Cachorro extends Animal {
+
+    public function emitirSom()
+    {
+        echo "Au au";
+    }
+
+}
+
+class Gato extends Animal {
+
+    public function emitirSom()
+    {
+        echo "Miau";
+    }
+
+}
+```
+
+---
+
+## Utilizando
+
+```php
+<?php
+
+$animal1 = new Cachorro();
+$animal2 = new Gato();
+
+echo $animal1->emitirSom() . PHP_EOL;
+echo $animal2->emitirSom() . PHP_EOL;
+```
+
+---
+
+##  Outro exemplo (mais real)
+
+```php
+<?php
+
+class Pagamento {
+
+    public function pagar($valor)
+    {
+        echo "Pagamento genérico de R$ $valor";
+    }
+
+}
+
+class Pix extends Pagamento {
+
+    public function pagar($valor)
+    {
+        echo "Pagamento via PIX de R$ $valor";
+    }
+
+}
+
+class Cartao extends Pagamento {
+
+    public function pagar($valor)
+    {
+        echo "Pagamento no cartão de R$ $valor";
+    }
+
+}
+```
+
+### Usando:
+
+```php
+<?php
+
+$pagamentos = [
+    new Pix(),
+    new Cartao()
+];
+
+foreach ($pagamentos as $pagamento) {
+    $pagamento->pagar(100) . PHP_EOL;
+}
+```
+
+---
+
+## Sem polimorfismo
+
+```php
+if ($tipo == 'pix') {
+    echo "Pagamento via PIX";
+} elseif ($tipo == 'cartao') {
+    echo "Pagamento no cartão";
+}
+```
+
+❌ Difícil de manter
+❌ Cresce rápido demais
+
+---
+
+## Com polimorfismo
+
+```php
+$pagamento->pagar(100);
+```
+
+✔️ Limpo
+✔️ Reutilizável
+✔️ Escalável
+
+---
+
+## Resumão !!!
+
+* Mesmo método (`pagar`, `emitirSom`)
+* Classes diferentes
+* Resultados diferentes
+
+---
+
+## 🧩 Frase pra guardar
+
+> **Polimorfismo é usar o mesmo método com comportamentos diferentes em objetos diferentes.**
+
+---