Quais são os quatro pilares da POO?

Question

Accepted Answer

A programação orientada a objetos repousa sobre quatro princípios fundamentais — **Encapsulamento, Herança, Polimorfismo e Abstração**. Java é construído em torno desses conceitos, e compreendê-los é essencial para projetar programas Java.

## 1. Encapsulamento — agrupar dados + ocultar internos

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

O encapsulamento oculta o estado interno (`private`) e expõe acesso controlado (métodos públicos/getters/setters). Isso protege invariantes — você não pode definir um saldo negativo diretamente — e permite alterar internamente sem quebrar quem chama.

## 2. Herança — reutilização via relação "é um"

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — inherits eat()
    void bark() { System.out.println("woof"); }
}
```

A herança permite que uma subclasse reutilize e estenda o comportamento de uma superclasse, modelando relações "é um" e evitando duplicação de código.

## 3. Polimorfismo — uma interface, muitas formas

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

O polimorfismo permite tratar diferentes subclasses uniformemente através de um tipo comum, com o método sobrescrito do objeto **real** sendo chamado em tempo de execução — possibilitando código flexível e extensível.

## 4. Abstração — expor o quê, ocultar como

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

A abstração (via interfaces/classes abstratas) expõe um contrato simplificado enquanto oculta implementação complexa — permitindo trocar implementações e reduzir acoplamento.

## Por que isso importa

Os quatro pilares são a base do design orientado a objetos e do próprio Java.

O encapsulamento protege a integridade dos dados e permite mudanças seguras; a herança promove reutilização; o polimorfismo oferece flexibilidade e extensibilidade (tratar muitos tipos uniformemente, comportamento resolvido em tempo de execução); a abstração reduz acoplamento e complexidade.

Compreendê-los não é apenas terminologia — eles orientam como você estrutura classes, projeta APIs e constrói sistemas mantíveis e extensíveis.

Também estão entre os tópicos de entrevista mais comuns porque revelam se um desenvolvedor pensa em termos adequados de POO, o que é essencial para trabalhar efetivamente no ecossistema centrado em classes do Java.