Neste artigo
- De onde veio o SOLID?
- S: o que é o princípio da responsabilidade única?
- O: o que é o princípio aberto/fechado?
- L: o que é o princípio da substituição de Liskov?
- I: o que é o princípio da segregação de interfaces?
- D: o que é o princípio da inversão de dependência?
- O que muda do PHP para o Java e o C#?
- Aí você pergunta: preciso aplicar os cinco princípios em tudo?
- Agora é com você!
SOLID é um conjunto de cinco princípios de orientação a objetos que ajudam a escrever código mais fácil de entender, de alterar e de manter. Cada letra da sigla é a inicial de um princípio.
No último artigo fechamos a trilha de estruturas de dados com a tabela hash. Hoje começamos outra: a de orientação a objetos na prática. Se você ainda não viu o básico de classes e objetos, comece por Aprenda Programação Orientada a Objetos (POO) de uma vez por todas e depois volte aqui.
De onde veio o SOLID?
Os princípios foram reunidos pelo engenheiro de software Robert C. Martin, o “Uncle Bob”, em um artigo do ano 2000. A sigla veio depois, por volta de 2004: foi sugerida a Martin por Michael Feathers.
| Letra | Princípio | Em uma frase |
|---|---|---|
| S | Responsabilidade única (Single Responsibility) | Uma classe deve ter um único motivo para mudar |
| O | Aberto/fechado (Open/Closed) | Aberta para extensão, fechada para modificação |
| L | Substituição de Liskov (Liskov Substitution) | Quem herda deve poder ocupar o lugar de quem foi herdado |
| I | Segregação de interfaces (Interface Segregation) | Ninguém deve ser obrigado a depender do que não usa |
| D | Inversão de dependência (Dependency Inversion) | Dependa de abstrações, e não de implementações |
Calma, parece muito “tecniquês”, eu sei kkkk. Vamos um por um, sempre com um exemplo do dia a dia. Os exemplos estão em PHP, em Java e em C#, com a mesma saída nas três. Você já sabe: foque no conceito, e não na linguagem!
S: o que é o princípio da responsabilidade única?
Pense em um restaurante. O cozinheiro cozinha, o garçom atende e o caixa cobra. Se uma pessoa só fizesse tudo, qualquer mudança no cardápio, no atendimento ou na forma de pagamento cairia nas costas dela. Com classes é igual: uma classe deve ter um único motivo para mudar.

Imagine uma classe de pedido que calcula o total, grava no banco de dados e ainda envia e-mail. São três motivos diferentes para mexer nela! O caminho é separar:
Em PHP:
<?php
class Order
{
public function __construct(private array $prices)
{
}
public function total(): float
{
return array_sum($this->prices);
}
}
class OrderRepository
{
public function save(Order $order): void
{
echo 'Pedido salvo', PHP_EOL; // aqui entraria o banco de dados
}
}
class OrderMailer
{
public function send(Order $order): void
{
echo 'E-mail enviado. Total: ', $order->total(), PHP_EOL;
}
}
$order = new Order([40.0, 60.0]);
(new OrderRepository())->save($order); // Pedido salvo
(new OrderMailer())->send($order); // E-mail enviado. Total: 100
Em Java:
import java.util.List;
class Order {
private final List<Double> prices;
Order(List<Double> prices) {
this.prices = prices;
}
double total() {
double sum = 0;
for (double price : prices) {
sum += price;
}
return sum;
}
}
class OrderRepository {
void save(Order order) {
System.out.println("Pedido salvo"); // aqui entraria o banco de dados
}
}
class OrderMailer {
void send(Order order) {
System.out.printf("E-mail enviado. Total: %.0f%n", order.total());
}
}
public class Main {
public static void main(String[] args) {
Order order = new Order(List.of(40.0, 60.0));
new OrderRepository().save(order); // Pedido salvo
new OrderMailer().send(order); // E-mail enviado. Total: 100
}
}
Em C#:
using System;
using System.Linq;
var order = new Order(new[] { 40.0, 60.0 });
new OrderRepository().Save(order); // Pedido salvo
new OrderMailer().Send(order); // E-mail enviado. Total: 100
class Order
{
private readonly double[] prices;
public Order(double[] prices)
{
this.prices = prices;
}
public double Total()
{
return prices.Sum();
}
}
class OrderRepository
{
public void Save(Order order)
{
Console.WriteLine("Pedido salvo"); // aqui entraria o banco de dados
}
}
class OrderMailer
{
public void Send(Order order)
{
Console.WriteLine($"E-mail enviado. Total: {order.Total()}");
}
}
Mudou a regra do e-mail? Você mexe só no OrderMailer. O resto nem fica sabendo.
O: o que é o princípio aberto/fechado?
Pense na tomada da sua casa. Para ligar um aparelho novo, você não quebra a parede e refaz a fiação: só encaixa o plugue. A tomada está fechada para modificação e aberta para extensão.
No código, isso significa conseguir acrescentar um comportamento novo sem alterar o que já funciona. Em vez de encher a calculadora de if para cada tipo de desconto, cada desconto vira uma classe:
Em PHP:
<?php
interface Discount
{
public function apply(float $price): float;
}
class NoDiscount implements Discount
{
public function apply(float $price): float
{
return $price;
}
}
class ChristmasDiscount implements Discount
{
public function apply(float $price): float
{
return $price * 0.9; // 10% de desconto
}
}
class PriceCalculator
{
public function finalPrice(float $price, Discount $discount): float
{
return $discount->apply($price);
}
}
$calculator = new PriceCalculator();
echo $calculator->finalPrice(200.0, new NoDiscount()), PHP_EOL; // 200
echo $calculator->finalPrice(200.0, new ChristmasDiscount()), PHP_EOL; // 180
Em Java:
interface Discount {
double apply(double price);
}
class NoDiscount implements Discount {
public double apply(double price) {
return price;
}
}
class ChristmasDiscount implements Discount {
public double apply(double price) {
return price * 0.9; // 10% de desconto
}
}
class PriceCalculator {
double finalPrice(double price, Discount discount) {
return discount.apply(price);
}
}
public class Main {
public static void main(String[] args) {
PriceCalculator calculator = new PriceCalculator();
System.out.printf("%.0f%n", calculator.finalPrice(200.0, new NoDiscount())); // 200
System.out.printf("%.0f%n", calculator.finalPrice(200.0, new ChristmasDiscount())); // 180
}
}
Em C#:
using System;
var calculator = new PriceCalculator();
Console.WriteLine(calculator.FinalPrice(200.0, new NoDiscount())); // 200
Console.WriteLine(calculator.FinalPrice(200.0, new ChristmasDiscount())); // 180
interface IDiscount
{
double Apply(double price);
}
class NoDiscount : IDiscount
{
public double Apply(double price)
{
return price;
}
}
class ChristmasDiscount : IDiscount
{
public double Apply(double price)
{
return price * 0.9; // 10% de desconto
}
}
class PriceCalculator
{
public double FinalPrice(double price, IDiscount discount)
{
return discount.Apply(price);
}
}
Surgiu o desconto de Black Friday? Você cria uma classe nova que implementa Discount, e o PriceCalculator continua intacto. Essa ideia está por trás de vários padrões de projeto, como o Strategy.
L: o que é o princípio da substituição de Liskov?
O nome vem da cientista da computação Barbara Liskov. A ideia: se uma classe herda de outra, ou implementa uma interface, ela precisa cumprir tudo o que a original promete. Quem usa a original não pode levar um susto ao receber a filha no lugar.
O exemplo clássico: uma classe de ave com o método voar. Aí chega o pinguim… Ele é uma ave, mas não voa! Se o pinguim herdar o método voar e devolver um erro, todo código que espera uma ave que voa vai quebrar. A solução é não prometer o que nem toda ave cumpre:
Em PHP:
<?php
interface Bird
{
public function eat(): string;
}
interface FlyingBird extends Bird
{
public function fly(): string;
}
class Sparrow implements FlyingBird
{
public function eat(): string
{
return 'O pardal está comendo';
}
public function fly(): string
{
return 'O pardal está voando';
}
}
class Penguin implements Bird
{
public function eat(): string
{
return 'O pinguim está comendo';
}
}
function feed(Bird $bird): void
{
echo $bird->eat(), PHP_EOL; // funciona com qualquer ave
}
function release(FlyingBird $bird): void
{
echo $bird->fly(), PHP_EOL; // só aceita ave que voa
}
feed(new Sparrow()); // O pardal está comendo
feed(new Penguin()); // O pinguim está comendo
release(new Sparrow()); // O pardal está voando
Em Java:
interface Bird {
String eat();
}
interface FlyingBird extends Bird {
String fly();
}
class Sparrow implements FlyingBird {
public String eat() {
return "O pardal está comendo";
}
public String fly() {
return "O pardal está voando";
}
}
class Penguin implements Bird {
public String eat() {
return "O pinguim está comendo";
}
}
public class Main {
static void feed(Bird bird) {
System.out.println(bird.eat()); // funciona com qualquer ave
}
static void release(FlyingBird bird) {
System.out.println(bird.fly()); // só aceita ave que voa
}
public static void main(String[] args) {
feed(new Sparrow()); // O pardal está comendo
feed(new Penguin()); // O pinguim está comendo
release(new Sparrow()); // O pardal está voando
}
}
Em C#:
using System;
Feed(new Sparrow()); // O pardal está comendo
Feed(new Penguin()); // O pinguim está comendo
Release(new Sparrow()); // O pardal está voando
void Feed(IBird bird)
{
Console.WriteLine(bird.Eat()); // funciona com qualquer ave
}
void Release(IFlyingBird bird)
{
Console.WriteLine(bird.Fly()); // só aceita ave que voa
}
interface IBird
{
string Eat();
}
interface IFlyingBird : IBird
{
string Fly();
}
class Sparrow : IFlyingBird
{
public string Eat()
{
return "O pardal está comendo";
}
public string Fly()
{
return "O pardal está voando";
}
}
class Penguin : IBird
{
public string Eat()
{
return "O pinguim está comendo";
}
}
Agora o próprio tipo avisa: a função release só aceita ave que voa. Testei passar um pinguim para ela nas três linguagens. O PHP recusou na hora em que a linha foi executada, com um erro de tipo. O Java e o C# recusaram antes: o compilador nem deixou o programa rodar.
PHP: TypeError: release(): Argument #1 ($bird) must be of type FlyingBird, Penguin given Java: error: incompatible types: Penguin cannot be converted to FlyingBird C#: error CS1503: Argument 1: cannot convert from 'Penguin' to 'IFlyingBird'
Melhor descobrir assim do que com o sistema no ar!
I: o que é o princípio da segregação de interfaces?
Pense em um controle remoto com 60 botões, dos quais você usa 5 kkkk. Interface grande demais é isso: obriga quem implementa a carregar o que não usa.
Se existisse uma interface única com imprimir e digitalizar, uma impressora simples seria obrigada a ter um método de digitalizar que não faz nada. Melhor ter interfaces pequenas e específicas:
Em PHP:
<?php
interface Printer
{
public function print(string $document): string;
}
interface Scanner
{
public function scan(): string;
}
class SimplePrinter implements Printer
{
public function print(string $document): string
{
return "Imprimindo: $document";
}
}
class MultifunctionPrinter implements Printer, Scanner
{
public function print(string $document): string
{
return "Imprimindo: $document";
}
public function scan(): string
{
return 'Digitalizando...';
}
}
echo (new SimplePrinter())->print('contrato.pdf'), PHP_EOL; // Imprimindo: contrato.pdf
echo (new MultifunctionPrinter())->scan(), PHP_EOL; // Digitalizando...
Em Java:
interface Printer {
String print(String document);
}
interface Scanner {
String scan();
}
class SimplePrinter implements Printer {
public String print(String document) {
return "Imprimindo: " + document;
}
}
class MultifunctionPrinter implements Printer, Scanner {
public String print(String document) {
return "Imprimindo: " + document;
}
public String scan() {
return "Digitalizando...";
}
}
public class Main {
public static void main(String[] args) {
System.out.println(new SimplePrinter().print("contrato.pdf")); // Imprimindo: contrato.pdf
System.out.println(new MultifunctionPrinter().scan()); // Digitalizando...
}
}
Em C#:
using System;
Console.WriteLine(new SimplePrinter().Print("contrato.pdf")); // Imprimindo: contrato.pdf
Console.WriteLine(new MultifunctionPrinter().Scan()); // Digitalizando...
interface IPrinter
{
string Print(string document);
}
interface IScanner
{
string Scan();
}
class SimplePrinter : IPrinter
{
public string Print(string document)
{
return $"Imprimindo: {document}";
}
}
class MultifunctionPrinter : IPrinter, IScanner
{
public string Print(string document)
{
return $"Imprimindo: {document}";
}
public string Scan()
{
return "Digitalizando...";
}
}
D: o que é o princípio da inversão de dependência?
Volte à tomada. O seu notebook não depende da usina que gera a energia: ele depende do padrão da tomada. Pode trocar a usina, que o notebook continua funcionando.
No código, a classe mais importante, que guarda a regra do negócio, não deve depender dos detalhes, como um serviço de pagamento específico. As duas dependem de uma abstração, que nas três linguagens é uma interface:
Em PHP:
<?php
interface PaymentGateway
{
public function charge(float $amount): string;
}
class PixGateway implements PaymentGateway
{
public function charge(float $amount): string
{
return "Cobrança de $amount via Pix";
}
}
class CardGateway implements PaymentGateway
{
public function charge(float $amount): string
{
return "Cobrança de $amount no cartão";
}
}
class Checkout
{
// o Checkout conhece só a interface, e não quem cobra de verdade
public function __construct(private PaymentGateway $gateway)
{
}
public function pay(float $amount): string
{
return $this->gateway->charge($amount);
}
}
echo (new Checkout(new PixGateway()))->pay(150.0), PHP_EOL; // Cobrança de 150 via Pix
echo (new Checkout(new CardGateway()))->pay(150.0), PHP_EOL; // Cobrança de 150 no cartão
Em Java:
interface PaymentGateway {
String charge(double amount);
}
class PixGateway implements PaymentGateway {
public String charge(double amount) {
return String.format("Cobrança de %.0f via Pix", amount);
}
}
class CardGateway implements PaymentGateway {
public String charge(double amount) {
return String.format("Cobrança de %.0f no cartão", amount);
}
}
class Checkout {
// o Checkout conhece só a interface, e não quem cobra de verdade
private final PaymentGateway gateway;
Checkout(PaymentGateway gateway) {
this.gateway = gateway;
}
String pay(double amount) {
return gateway.charge(amount);
}
}
public class Main {
public static void main(String[] args) {
System.out.println(new Checkout(new PixGateway()).pay(150.0)); // Cobrança de 150 via Pix
System.out.println(new Checkout(new CardGateway()).pay(150.0)); // Cobrança de 150 no cartão
}
}
Em C#:
using System;
Console.WriteLine(new Checkout(new PixGateway()).Pay(150.0)); // Cobrança de 150 via Pix
Console.WriteLine(new Checkout(new CardGateway()).Pay(150.0)); // Cobrança de 150 no cartão
interface IPaymentGateway
{
string Charge(double amount);
}
class PixGateway : IPaymentGateway
{
public string Charge(double amount)
{
return $"Cobrança de {amount} via Pix";
}
}
class CardGateway : IPaymentGateway
{
public string Charge(double amount)
{
return $"Cobrança de {amount} no cartão";
}
}
class Checkout
{
// o Checkout conhece só a interface, e não quem cobra de verdade
private readonly IPaymentGateway gateway;
public Checkout(IPaymentGateway gateway)
{
this.gateway = gateway;
}
public string Pay(double amount)
{
return gateway.Charge(amount);
}
}
O Checkout não sabe se a cobrança é por Pix ou por cartão, e nem precisa saber. Quer trocar o meio de pagamento, ou usar um de mentira nos testes? É só entregar outro objeto que implemente PaymentGateway.
O que muda do PHP para o Java e o C#?
Os cinco princípios são os mesmos. O que muda é a escrita, e o momento em que o erro aparece:
- Interface: a ideia é igual nas três, um contrato que a classe promete cumprir. Em PHP e em Java, a classe usa a palavra implements. Em C#, a interface vem depois de dois-pontos.
- Nome da interface em C#: por convenção, começa com I maiúsculo. Por isso Discount virou IDiscount, e Bird virou IBird.
- Mais de uma interface: a MultifunctionPrinter implementa duas interfaces nas três linguagens, separadas por vírgula.
- Erro de tipo: o Java e o C# passam por um compilador antes de rodar, e foi ele que barrou o pinguim. No PHP, o erro só apareceu quando a linha foi executada.
- Número com casas decimais: em Java, mandar imprimir o valor 100.0 mostra 100.0. Usei o printf com %.0f para a saída ficar igual à do PHP e à do C#, que mostraram 100.
Para rodar cada exemplo, usei estes comandos:
php exemplo.php javac Main.java java Main dotnet run
Aí você pergunta: preciso aplicar os cinco princípios em tudo?
NÃO! Um erro comum de quem acabou de conhecer o SOLID é sair criando interface para tudo. Princípio não é lei: é um guia para quando o código começa a doer. Uma classe pequena, que quase não muda, não precisa de cinco interfaces.
Use o SOLID quando perceber que mexer em um lugar quebra outro, ou que uma classe virou um “faz-tudo”. Vou repetir porque é importante: primeiro entenda o problema, depois escolha o princípio.
Agora é com você!
Escolha uma classe de um projeto seu, mesmo que seja um exercício de estudo. No papel, responda: quantos motivos diferentes essa classe tem para mudar? Liste cada um. Se passou de um, como você separaria?
Não existe uma resposta única, e é por isso mesmo que o exercício vale: é o SEU raciocínio que está sendo treinado. Ferramenta nenhuma conhece o seu projeto melhor do que você!
No próximo artigo vamos falar de uma dúvida de muita gente que está começando: se a inteligência artificial já escreve código, ainda vale a pena aprender a programar? Até lá!
Confiança Sempre!!!
Fontes:
- Robert C. Martin. The Principles of OOD (em inglês).
- North Carolina State University, CSC/ECE 517. Object-Oriented Languages and Systems, Week 8 (PDF, em inglês), com Robert “Uncle Bob” Martin apresentado como o arquiteto dos princípios SOLID e a sigla descrita como cinco princípios de projeto.
- Robert C. Martin. Design Principles and Design Patterns (em inglês), o artigo de 2000 em que os princípios aparecem reunidos.
- Syracuse University, CSE687. Object Oriented Design Principles (em inglês), com os princípios aberto/fechado, de Liskov, da inversão de dependência e da segregação de interfaces.
- DePaul University, SE 350. SOLID (em inglês), com um exemplo de violação e de correção para cada princípio.
- Texas A&M University, CSCE 315. SOLID Principles for Object-Oriented Design (em inglês), com o histórico dos princípios.
- Better Scientific Software. Digging Deeper into Agile Software Development (em inglês), com o enunciado dos princípios no livro de 2003 de Robert C. Martin.
- Packt. Software Architecture with Spring 5.0, capítulo 1: SOLID principles (livro, em inglês), com a sigla sugerida por Michael Feathers a Robert C. Martin em 2004.
- Oracle. The Java Tutorials: Interfaces (em inglês), sobre a interface como contrato e a palavra implements.
- Microsoft Learn. Interfaces em C#, sobre a interface como contrato, a implementação de várias interfaces e a convenção do I maiúsculo no nome.
- Microsoft Learn. Princípios de arquitetura, com a responsabilidade única e a inversão de dependência em aplicações .NET.
- Os exemplos foram executados em PHP 8.3, Java 21 e .NET 8.

Continue a conversa