Paradigma de Programação Orientada a Objetos (POO)

Introdução

A Programação Orientada a Objetos nasceu com a linguagem Simula 67, considerada a primeira linguagem orientada a objetos, e foi consolidada e popularizada por Smalltalk nos anos 1970. Ganhou adoção massiva na indústria com C++ e, posteriormente, Java e C#. A ideia central é organizar o código em torno de objetos: unidades que combinam dados (atributos/estado) e comportamento (métodos) em uma única estrutura.

Os quatro pilares

1. Encapsulamento — os dados internos de um objeto são protegidos e só podem ser acessados/alterados através de métodos expostos, escondendo detalhes de implementação do mundo externo.
2. Abstração — o objeto expõe apenas o que é relevante para quem o utiliza, escondendo a complexidade interna (ex.: você chama CalcularSalario() sem precisar saber como o cálculo é feito por dentro).
3. Herança — uma classe pode herdar atributos e métodos de outra, permitindo reaproveitamento e especialização (uma classe Desenvolvedor pode herdar de Funcionario).
4. Polimorfismo — objetos de classes diferentes podem responder de forma diferente ao mesmo "chamado" (o mesmo método CalcularSalario() se comporta de forma distinta para um Desenvolvedor e para um Gerente, por exemplo).

Exemplo

// Exemplo de Programação Orientada a Objetos em C#
public abstract class Funcionario
{
    public string Nome { get; }
    protected decimal SalarioBase { get; }

    protected Funcionario(string nome, decimal salarioBase)
    {
        Nome = nome;
        SalarioBase = salarioBase;
    }

    // Abstração: cada subclasse decide como calcular seu próprio salário
    public abstract decimal CalcularSalario();
}

public class Desenvolvedor : Funcionario
{
    private int BonusPorProjeto { get; }

    public Desenvolvedor(string nome, decimal salarioBase, int bonusPorProjeto)
        : base(nome, salarioBase) // Herança
    {
        BonusPorProjeto = bonusPorProjeto;
    }

    // Polimorfismo: implementação específica do método herdado
    public override decimal CalcularSalario()
    {
        return SalarioBase + BonusPorProjeto;
    }
}

public class Gerente : Funcionario
{
    private decimal BonusPorEquipe { get; }

    public Gerente(string nome, decimal salarioBase, decimal bonusPorEquipe)
        : base(nome, salarioBase)
    {
        BonusPorEquipe = bonusPorEquipe;
    }

    public override decimal CalcularSalario()
    {
        return SalarioBase + BonusPorEquipe;
    }
}

Aqui, SalarioBase é protegido (encapsulamento), Desenvolvedor e Gerente reaproveitam a estrutura de Funcionario (herança), e cada um implementa CalcularSalario() à sua maneira (polimorfismo) — tudo isso sem que o código que consome Funcionario precise saber qual subtipo específico está manipulando.

Vantagens e limitações

• Vantagens: modela bem domínios do mundo real com entidades ricas e relacionamentos complexos; favorece reuso e organização em sistemas grandes; se encaixa naturalmente em arquiteturas como Clean Architecture e DDD (Domain-Driven Design).
• Limitações: hierarquias de herança profundas podem se tornar rígidas e difíceis de alterar; o estado mutável encapsulado em objetos ainda pode gerar efeitos colaterais difíceis de rastrear se mal gerenciado.

Linguagens representativas: Java, C#, Python, C++, TypeScript (com classes).