Quais são os princípios SOLID?

Question

Accepted Answer

**SOLID** é um conjunto de cinco princípios de design orientado a objetos que promovem código **mantível, flexível, compreensível**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation e Dependency Inversion. Eles guiam um bom design OO.

## Os cinco princípios

```text
S — SINGLE RESPONSIBILITY → a class should have ONE reason to change (one responsibility/job)
  → don't make classes do too much (avoid God objects)
O — OPEN/CLOSED → open for EXTENSION, closed for MODIFICATION → add new behavior without
  changing existing code (e.g. via polymorphism/strategies)
L — LISKOV SUBSTITUTION → subtypes must be substitutable for their base types (a subclass
  shouldn't break behavior expected of the parent)
I — INTERFACE SEGREGATION → many specific interfaces > one fat interface → clients shouldn't
  depend on methods they don't use
D — DEPENDENCY INVERSION → depend on ABSTRACTIONS, not concrete implementations → high-level
  modules don't depend on low-level details (relates to DI)
```

## Por que isso importa

```text
✓ MAINTAINABILITY → easier to change/extend code without breaking things
✓ FLEXIBILITY → loosely-coupled, extensible designs (add features, swap parts)
✓ TESTABILITY → decoupled code (especially via Dependency Inversion) is easier to test
✓ UNDERSTANDABILITY → focused, well-organized classes; clearer responsibilities
→ SOLID principles guide writing better OO code (reduce coupling, increase cohesion)
```

## Aplicando SOLID (com julgamento)

```text
✓ Use them as GUIDELINES → they generally lead to better designs
⚠️ Don't apply DOGMATICALLY → over-applying (especially adding abstraction everywhere) →
  over-engineering; balance with simplicity and pragmatism (YAGNI)
→ understand the PRINCIPLES and apply them with judgment
```

## Por que isso importa

Compreender os princípios SOLID é valioso porque eles são **diretrizes fundamentais para um bom design orientado a objetos**, amplamente ensinados e aplicados, então são conhecimentos de design importantes para escrever código mantível.

SOLID — cinco princípios que promovem código mantível, flexível e compreensível — fornece orientação fundamental para design OO.

Compreender os **cinco princípios** — **Single Responsibility** (uma classe tendo uma razão para mudar, evitando objetos God), **Open/Closed** (aberto para extensão, fechado para modificação — adicionando comportamento sem alterar código existente, por exemplo via o padrão Strategy), **Liskov Substitution** (subtipos substituíveis por tipos base sem quebrar comportamento esperado), **Interface Segregation** (interfaces específicas em vez de gordas, para que clientes não dependam de métodos não utilizados) e **Dependency Inversion** (dependendo de abstrações não de implementações concretas — intimamente relacionado a dependency injection) — fornece um framework para um bom design OO que reduz acoplamento e aumenta coesão.

Compreender **por que SOLID importa** — melhorando manutenibilidade (mais fácil mudar e estender sem quebrar coisas), flexibilidade (designs fracamente acoplados, extensíveis), testabilidade (código desacoplado, especialmente via Dependency Inversion, sendo mais fácil de testar) e compreensibilidade (classes focadas, bem organizadas) — esclarece os benefícios que esses princípios fornecem.

Crucialmente, compreender **aplicar SOLID com julgamento** — usando os princípios como diretrizes que geralmente levam a designs melhores, mas **não aplicando-os dogmaticamente** (over-aplicar, especialmente adicionando abstração em toda parte, causa over-engineering, então equilibre com simplicidade e pragmatismo) — reflete sentido de design maturo, já que SOLID pode ser over-aplicado assim como padrões podem.

SOLID é amplamente ensinado e referenciado como orientação fundamental de design OO.

Como os princípios SOLID são diretrizes fundamentais, amplamente ensinadas para um bom design orientado a objetos (promovendo manutenibilidade, flexibilidade, testabilidade e compreensibilidade) e aplicá-los com julgamento melhora o código, e como compreender os princípios, seus benefícios e a necessidade de aplicação equilibrada é importante para escrever código mantível, compreender os princípios SOLID é conhecimento de design valioso e praticamente relevante — diretrizes fundamentais para um bom design OO amplamente ensinadas e aplicadas, importantes para escrever código mantível e flexível e refletindo o conhecimento de design (com o julgamento para aplicá-los pragmaticamente) esperado de desenvolvedores escrevendo software orientado a objetos.