Voltar ao Blog

O que é Programação Orientada a Objetos (POO)?

23 de fevereiro de 2026

Se você já ouviu falar em POO e ficou confuso, relaxa. Neste post vou te explicar de um jeito simples, usando exemplos do dia a dia com Python.

O problema que a POO resolve

Imagina que você precisa gerenciar informações de vários cachorros em um sistema. Sem POO, você faria algo assim:

cachorro_nome = "Maya"
cachorro_raca = "Lulu da Pomerânia"
cachorro_idade = 3

cachorro2_nome = "Pancho"
cachorro2_raca = "Bulldog Inglês"
cachorro2_idade = 5

Deu pra sentir o caos que isso vira com 100 cachorros, né? A POO existe justamente para organizar isso de forma inteligente.

O conceito central: Classe e Objeto

Pensa em uma Classe como uma planta baixa de uma casa. Ela define como a casa vai ser — quantos quartos, banheiros, etc. Mas a planta em si não é uma casa.

Um Objeto é a casa construída a partir dessa planta. Você pode construir várias casas diferentes usando a mesma planta.

# Classe = a "planta baixa" do cachorro
class Cachorro:
    def __init__(self, nome: str, raca: str, idade: int):
        self.nome = nome
        self.raca = raca
        self.idade = idade

    def latir(self) -> str:
        return f"{self.nome} diz: Au au!"

# Objetos = cachorros reais criados a partir da planta
maya = Cachorro(nome="Maya", raca="Lulu da Pomerânia", idade=3)
pancho = Cachorro(nome="Pancho", raca="Bulldog Inglês", idade=5)

print(maya.latir())    # Maya diz: Au au!
print(pancho.latir())  # Pancho diz: Au au!

Muito mais organizado, certo?

Os 4 pilares da POO

1. Encapsulamento — "O que é meu, é meu"

Encapsulamento é proteger os dados internos de um objeto. Você expõe apenas o que é necessário para o mundo externo.

class ContaBancaria:
    def __init__(self, saldo_inicial: float):
        self.__saldo = saldo_inicial  # atributo privado (__)

    def depositar(self, valor: float) -> None:
        if valor > 0:
            self.__saldo += valor

    def get_saldo(self) -> float:
        return self.__saldo

conta = ContaBancaria(saldo_inicial=1000.0)
conta.depositar(500.0)
print(conta.get_saldo())  # 1500.0

# conta.__saldo  ← isso quebraria! O saldo está protegido.

2. Herança — "Filho herda do pai"

Herança permite criar uma nova classe baseada em outra, aproveitando o que já existe e adicionando ou modificando comportamentos.

class Animal:
    def __init__(self, nome: str):
        self.nome = nome

    def fazer_som(self) -> str:
        return "..."

class Cachorro(Animal):
    def fazer_som(self) -> str:
        return "Au au!"

class Gato(Animal):
    def fazer_som(self) -> str:
        return "Miau!"

maya = Cachorro("Maya")
romeu = Gato("Romeu")

print(maya.fazer_som())   # Au au!
print(romeu.fazer_som())  # Miau!

Cachorro e Gato herdaram nome de Animal e cada um definiu seu próprio som. Simples assim.

3. Polimorfismo — "Mesma ação, comportamentos diferentes"

Polimorfismo é quando objetos de tipos diferentes respondem ao mesmo método de formas distintas. No exemplo acima já vimos isso em ação: fazer_som() se comporta diferente para cada animal.

animais = [Cachorro("Maya"), Gato("Romeu"), Cachorro("Pancho")]

for animal in animais:
    print(f"{animal.nome}: {animal.fazer_som()}")

# Maya: Au au!
# Romeu: Miau!
# Pancho: Au au!

O código não precisa saber qual tipo de animal é — ele simplesmente chama fazer_som() e cada objeto sabe o que fazer.

4. Abstração — "Esconder a complexidade"

Abstração é mostrar apenas o essencial, escondendo os detalhes internos. Quando você dirige um carro, você não precisa saber como o motor funciona por dentro — só precisa saber usar o volante e os pedais.

from abc import ABC, abstractmethod

class Forma(ABC):
    @abstractmethod
    def calcular_area(self) -> float:
        pass

class Retangulo(Forma):
    def __init__(self, largura: float, altura: float):
        self.largura = largura
        self.altura = altura

    def calcular_area(self) -> float:
        return self.largura * self.altura

class Circulo(Forma):
    def __init__(self, raio: float):
        self.raio = raio

    def calcular_area(self) -> float:
        return 3.14159 * self.raio ** 2

formas = [Retangulo(4, 5), Circulo(3)]

for forma in formas:
    print(f"Área: {forma.calcular_area():.2f}")

# Área: 20.00
# Área: 28.27

Quem usa calcular_area() não precisa saber como o cálculo é feito — só que vai funcionar.

Resumo rápido

PilarO que fazAnalogia
EncapsulamentoProtege os dados internosCaixa-forte do objeto
HerançaReutiliza código de outra classeFilho herda características do pai
PolimorfismoMesma interface, comportamentos diferentesMesma palavra, sentidos diferentes
AbstraçãoEsconde complexidade, expõe só o necessárioPainel do carro (não o motor)

Conclusão

A POO não é um bicho de sete cabeças. É basicamente uma forma de organizar seu código pensando no mundo real: você tem coisas (objetos), essas coisas têm características (atributos) e comportamentos (métodos).

Quando bem aplicada, a POO torna seu código mais legível, reutilizável e muito mais fácil de manter e escalar.

GitHub
LinkedIn