PHP

SOLID: os 5 princípios com analogias do dia a dia

Capa do artigo SOLID: os 5 princípios com analogias do dia a dia
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. De onde veio o SOLID?
  2. S: o que é o princípio da responsabilidade única?
  3. O: o que é o princípio aberto/fechado?
  4. L: o que é o princípio da substituição de Liskov?
  5. I: o que é o princípio da segregação de interfaces?
  6. D: o que é o princípio da inversão de dependência?
  7. O que muda do PHP para o Java e o C#?
  8. Aí você pergunta: preciso aplicar os cinco princípios em tudo?
  9. 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.

LetraPrincípioEm uma frase
SResponsabilidade única (Single Responsibility)Uma classe deve ter um único motivo para mudar
OAberto/fechado (Open/Closed)Aberta para extensão, fechada para modificação
LSubstituição de Liskov (Liskov Substitution)Quem herda deve poder ocupar o lugar de quem foi herdado
ISegregação de interfaces (Interface Segregation)Ninguém deve ser obrigado a depender do que não usa
DInversão de dependência (Dependency Inversion)Dependa de abstrações, e não de implementações
Os cinco princípios SOLID.

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.

História em quadrinhos em três quadros em um restaurante: cozinheiro, garçom e caixa, cada um com uma tarefa; depois, uma pessoa só cozinha, atende e cobra; por fim, as mudanças de cardápio, atendimento e pagamento caem todas sobre ela
Responsabilidade única no restaurante: quem faz tudo tem motivos demais 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:

Compartilhe este artigo

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Guardamos o IP e o navegador de quem comenta por 6 meses, para barrar spam e porque o Marco Civil da Internet pede a guarda dos registros de acesso por esse prazo. Veja como tratamos seus dados.

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e o código do registro dela, e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager.

Exibem anúncios do Google AdSense sem personalização. Os cookies desta categoria limitam a repetição dos anúncios e medem o resultado deles.

Usa a sua navegação para escolher anúncios e formar públicos de anúncio: anúncios do Google escolhidos pelos seus interesses e os indicadores do Google no Analytics. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.