<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by William Zampollo on Medium]]></title>
        <description><![CDATA[Stories by William Zampollo on Medium]]></description>
        <link>https://medium.com/@williamzampollo?source=rss-dc5eaf099119------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0jnT-KxvorJvHv9HwUM5hg.jpeg</url>
            <title>Stories by William Zampollo on Medium</title>
            <link>https://medium.com/@williamzampollo?source=rss-dc5eaf099119------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 14:30:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@williamzampollo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Construir sobre areia movediça]]></title>
            <link>https://medium.com/@williamzampollo/construir-sobre-areia-movedi%C3%A7a-c8b63d8245e4?source=rss-dc5eaf099119------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8b63d8245e4</guid>
            <category><![CDATA[carreira]]></category>
            <category><![CDATA[liderança]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[tecnologia]]></category>
            <dc:creator><![CDATA[William Zampollo]]></dc:creator>
            <pubDate>Tue, 01 Sep 2026 22:23:16 GMT</pubDate>
            <atom:updated>2026-09-01T22:23:16.598Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lOedSfmUGEGDIuko49ZQmA.jpeg" /></figure><p>Nos últimos meses perdi a conta de quantas vezes montei algo que ficou obsoleto antes de completar um trimestre.</p><p>Skills, agentes, harnesses, integrações. Você termina, documenta, e o time adota. Semanas depois o modelo evoluiu e metade das decisões de arquitetura já não se sustenta.</p><p>O ritmo é diferente de tudo que eu já vi antes. Não se parece com evolução tecnológica normal, é tipo acordar numa segunda com uma solução funcionando e ler na quinta um anúncio que torna metade das suas escolhas discutível.</p><p>A reação inicial e natural é frustração.</p><blockquote>Mas fui percebendo uma coisa: a frustração aparece quando o apego está na solução, e apego na solução costuma ser confusão entre meio e fim.</blockquote><h3>O que não muda</h3><p>Toda vez que montei um desses, tinham perguntas por trás.</p><blockquote>Como integrar IA num fluxo real sem criar dependência que o time não consegue manter?</blockquote><blockquote>Como manter controle quando parte do raciocínio está sendo delegada pra um modelo?</blockquote><blockquote>Como tirar fricção das partes do trabalho que não agregam valor?</blockquote><p>Essas perguntas continuam de pé, o que mudou foram as respostas disponíveis, e elas estão melhorando rápido. A implementação envelheceu, mas o problema continua exatamente onde estava, e essa distinção mudou um pouco como eu encaro o ciclo inteiro.</p><p>O que monto hoje é experimento informado, ele me ensina como os modelos se comportam na prática, onde falham, o que o time resiste em adotar, o que flui sozinho.</p><blockquote><strong>Esse aprendizado não some quando a ferramenta evolui, ele acumula.</strong></blockquote><h3>O custo de esperar</h3><p>O que me preocupa mais do que reconstruir é a postura de esperar o mercado assentar pra começar.</p><p>A lógica até parece razoável,<em> “Vamos deixar estabilizar antes de investir em algo que vai mudar.”</em> Acho que o aprendizado de navegar nesse ambiente não vem de observar, vem de construir, errar, desmontar e construir de novo.</p><p>Saber onde confiar no modelo e onde não confiar, saber que tipo de tarefa ele executa bem e onde ele alucina com uma confiança impressionante. Como o time reage quando a IA erra. O que precisa de revisão humana e o que pode ser delegado sem medo.</p><p>Isso não se lê em artigo nenhum e não se compra em treinamento, é julgamento, e julgamento vem de repetição com consequência real.</p><p>Quem está construindo agora, mesmo sobre &quot;areia movediça&quot;, está acumulando isso. E quem está esperando, vai chegar depois com a ferramenta certa na mão, sem saber para que ela funciona ou onde ela quebra.</p><h3>Navegar bem é a vantagem</h3><p>Em mercados estáveis como grades bancos, vence quem tem a melhor solução. Você otimiza, refina, defende o que construiu.</p><p>Aqui acho que a lógica se inverte. O que você construiu vale menos do que a velocidade com que você reconstrói quando precisa, sem perder o fio de por que está fazendo aquilo.</p><p>O que tento desenvolver todos os dias no time hoje é a capacidade de aprender, desaprender e remontar. Com direção, não com ansiedade.</p><blockquote>Conhecimento de ferramenta específica tem prazo de validade curto, e acho que todo mundo já percebeu isso.</blockquote><p>Tem uma habilidade subestimada nesse jogo: <strong>saber o que não jogar fora.<br></strong> Os critérios de qualidade, o entendimento do problema real, e a leitura de trade-offs, isso atravessa qualquer ciclo de ferramenta. É o que separa quem está reagindo ao próximo lançamento de quem está navegando com intenção.</p><h3>O que ficou de cada versão que joguei fora</h3><p>Cada vez que precisei remontar algo, saí com uma compreensão mais precisa do problema, não da ferramenta. E foi essa compreensão que me fez escolher melhor na iteração seguinte.</p><p>O campo ainda está se formando, quem estiver disposto a construir, errar e reconstruir, sem apego mas com direção, vai acumular uma vantagem que não tem atalho.</p><blockquote>A ferramenta certa você aprende em uma tarde, já o julgamento de saber quando ela <strong>não</strong> serve, leva um pouco mais de tempo.</blockquote><p>Valeu, até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8b63d8245e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como a IA está mudando a rotina dos devs]]></title>
            <link>https://medium.com/@williamzampollo/como-a-ia-est%C3%A1-mudando-a-rotina-dos-devs-a05e09d9aa30?source=rss-dc5eaf099119------2</link>
            <guid isPermaLink="false">https://medium.com/p/a05e09d9aa30</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[William Zampollo]]></dc:creator>
            <pubDate>Tue, 29 Jul 2025 22:49:57 GMT</pubDate>
            <atom:updated>2025-07-29T22:49:57.363Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ralJdZ0KdANj_4E5jqqbxA.png" /></figure><blockquote>Uma conversa franca sobre o que realmente mudou (e o que não mudou) no nosso dia a dia em tech, de acordo com a minha vivência.</blockquote><p>Quando o <strong>ChatGPT</strong> apareceu no final de 2022, confesso que eu era um pouco cético. Sabe aquele pensamento:<strong> &quot;<em>lá vem mais uma ferramenta prometendo revolucionar tudo, e vai acabar sendo só mais uma moda&quot;</em>?</strong> Pois é, dois anos depois, cá estou eu, retomando o hábito da escrita, e escrevendo justamente sobre como estava completamente enganado. 😬</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*JZlXF9OltLF4jeScea9NdA.gif" /></figure><p>Não porque a IA virou uma varinha mágica que resolve tudo, longe disso. Mas porque ela mudou profundamente a maneira como eu trabalho, como penso sobre problemas e até minha relação com o próprio código. E talvez você também esteja passando por isso, mesmo que ainda não tenha parado pra refletir.</p><p>Isso aqui não é mais um post com “10 prompts para turbinar sua produtividade”. É um papo real, baseado nas minhas experiências, frustrações legítimas e algumas descobertas que me surpreenderam pelo caminho.</p><h3>O que mudou minha perspectiva sobre o futuro da programação</h3><p>Antes de falar do dia a dia, preciso compartilhar algo que ajudou a mudar a minha perspectiva. Andrej Karpathy, sim, o cara que ajudou a fundar a OpenAI, e Steve Yegge, veterano da Amazon e Google, chegaram numa conclusão que vai contra tudo que você lê por aí.</p><blockquote>Enquanto todo mundo grita que “IA vai substituir todos os desenvolvedores”, esses dois estão dizendo exatamente o oposto: desenvolvedores estão prestes a se tornar mais valiosos, não menos.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Toh5_O42RmA-BmsQC_ka-w.png" /></figure><p>Estamos entrando no que Karpathy chama de “Software 3.0”. Se antes programávamos digitando código linha por linha, agora estamos aprendendo a <strong>“<em>conversar</em>”</strong> com sistemas inteligentes. E isso não diminui nossa importância, pelo contrário, <strong>multiplica</strong> ela.</p><p>Pense assim: se hoje existem cerca de 30 milhões de desenvolvedores no mundo, essa nova era pode criar mais de 1 bilhão de pessoas capazes de “<em>programar</em>” usando linguagem natural. <strong>Mas alguém ainda precisa entender o que está acontecendo por baixo dos panos, certo?</strong></p><h3>O que realmente mudou na prática</h3><p>Eu raramente uso IA para escrever código do zero. Estranho dizer isso num texto sobre o impacto da IA? Pode ser.</p><blockquote><strong>Mas a grande virada na minha visão não está na codificação em si, e sim em tudo que acontece ao redor.</strong></blockquote><p>Sabe aquele momento em que você trava porque esqueceu a sintaxe de algo trivial? Ou quando está com pressa e não lembra como configurar algo que já fez mil vezes? Pois é. Antes, era uma sequência de abas no Google, Stack Overflow, documentação… Agora, abro o ChatGPT, pergunto, leio a resposta, e volto direto ao problema de negócio, <strong>ganhei foco</strong>.</p><p>Pode parecer detalhe, mas multiplica isso pelas dezenas de microinterrupções diárias e o ganho vira gigante.</p><p>E por falar em ferramentas, a escolha do editor virou uma conversa interessante no time. Cursor virou queridinho de quem gosta de ter IA integrada direto no fluxo de código, é como ter um colega olhando por cima do ombro, mas sem ser invasivo. GitHub Copilot continua sendo o mais <em>“comportado”,</em> aquele que sugere na medida certa sem atrapalhar. Já o Windsurf chegou mais recente prometendo ser ainda mais contextual.</p><p>O curioso é que cada pessoa da equipe acabou gravitando pra uma ferramenta diferente, dependendo do estilo de trabalho. E isso gerou uma dinâmica nova: agora discutimos não só <strong><em>“como resolver X”</em></strong>, mas <strong><em>“qual ferramenta te ajudou a chegar nessa solução”</em></strong><em>.</em> Virou mais uma camada de conhecimento compartilhado.</p><p>E tem mais: essa mudança faz parte de algo maior. Estamos saindo da era de <strong><em>“memorizar APIs”</em></strong> para a era de <strong><em>“comunicar intenções”</em></strong>.</p><blockquote>Como o próprio Karpathy disse, “a linguagem de programação mais quente agora é o inglês”. E isso não me parece exagero.</blockquote><h3>Debugging e testes com IA: onde a mágica acontece</h3><p>Na minha visão onde a IA brilha mesmo para o Dev é no debugging e na criação de testes.</p><p>No debugging, ela me obriga a explicar o problema com clareza, e só isso já resolve metade da questão. Quando descrevo o comportamento estranho, ela devolve perguntas que me fazem pensar: <em>“Será que é diferença de ambiente?”, “Isso acontece sempre ou só às vezes?”.</em></p><p>Mas foi nos testes unitários que quando precisei, tive uma surpresa maior. Sabe aquela preguiça de escrever testes pra uma função óbvia? Agora é só copiar a função, pedir pra IA gerar os casos de teste, incluindo os edge cases que eu nunca lembro, e em 30 segundos tenho uma suíte básica rodando.</p><blockquote>Usando o Cursor IDE por ex. é ainda mais simples, basta um comando no prompt e boa, <strong>habemos testes!🪄</strong></blockquote><p>O interessante é que ela pensa em cenários que não passariam pela minha cabeça: <em>“E se o array vier vazio?”</em>, <em>“E se o usuário passar null?”</em>. Não é que eu não soubesse testar isso, mas na correria do dia a dia, esses detalhes ficam pra depois.</p><h3>O lado B: a dependência preguiçosa</h3><p>Nem tudo é maravilhoso. Percebi que tendemos a ficar meio preguiçosos com certas coisas. Antes, quando tinhamos dúvida, liamos a documentação, exploravamos, descobriamos funcionalidades que nem sabiamos que existiam. Agora? Perguntamos pra IA e seguimos em frente. <strong>Mais rápido, mas menos profundo.</strong></p><p>E isso tem um custo: menos aprendizado acidental, menos domínio real. Se amanhã precisar fazer algo mais complexo com aquela lib? Talvez eu não saiba por onde começar sem ajuda.</p><p>Minha regra tem sido: tudo bem usar IA, mas só se eu <strong>realmente entendo </strong>o que ela está sugerindo. Se não entendo, hora de abrir a doc e estudar.</p><blockquote>Porque no final das contas, se vamos viver nessa era do <em>“Software 3.0”,</em> precisamos ser os tradutores entre intenção humana e execução técnica. E isso exige entendimento profundo, não só copiar e colar.</blockquote><h3>A IA e a nova cultura de equipe</h3><p>Uma das mudanças mais interessantes que estou percebendo é na dinâmica dos times. Algumas discussões em code review já estão ficando mais ricas. Alguns devs já chegando com múltiplas soluções geradas por IA, e a conversa evolui para o <strong><em>“por que essa aqui faz mais sentido pra gente?”.</em></strong></p><blockquote><strong>Agora não compartilhamos só soluções. </strong>Compartilhamos prompts, raciocínios, versões de perguntas. Isso virou uma nova camada de colaboração.</blockquote><p>E faz sentido: se qualquer pessoa vai conseguir <em>“programar” </em>usando linguagem natural, o diferencial dos desenvolvedores profissionais está justamente nessas conversas mais profundas.</p><p>Com os devs junior, também mudou. Muitos conseguem tirar dúvidas básicas sozinhos com IA. Então quando nos procuram, é pra falar de arquitetura, trade-offs ou impacto no negócio, e isso elevou o nível das conversas. Mas nesse caso <strong><em>&quot;é uma faca de dois gumes&quot;</em></strong>, pois o dev junior precisa mais ainda entender o que está acontecendo por <em>&quot;debaixo dos panos&quot;</em>, e não confiar segamente nas soluções propostas pela IA.</p><h3>A IA vai te substituir?</h3><blockquote>Honestamente? Acho dificil!</blockquote><p>Com o tempo, entendo que a IA não vai substituir devs, mas ela vai substituir algumas tarefas. E isso muda o foco: <strong>cada vez mais nosso valor está em entender contexto, comunicar bem, pensar em arquitetura, fazer escolhas de produto.</strong></p><p>A IA escreve código, sim. Mas ela não entende o <em>“porquê”</em> daquele código, nem as consequências no longo prazo. Essas são as conversas que importam. <strong>E ainda são 100% humanas.</strong></p><blockquote><strong>Não é substituição, é evolução.</strong></blockquote><h3>O que vem por aí: “vibe coding” e o futuro próximo</h3><p>A ideia é que programação vai ficar cada vez mais intuitiva, baseada em comunicar a <em>“vibe”</em> do que você quer, em vez de especificar cada detalhe técnico.</p><p>Imagina poder dizer <em>“quero um sistema que funcione como o Spotify, mas para receitas de comida”</em> e ter uma base sólida pra começar. Não o produto final, mas uma fundação real que você pode iterar e refinar.</p><p>Isso não significa que vamos virar gerentes de projeto da IA. Significa que vamos poder focar no que realmente importa: <strong>resolver problemas humanos com tecnologia.</strong></p><h3>O que aprendi navegando essa transição</h3><ul><li><strong>Use com intenção</strong>: escolha uma área pra testar (testes unitários, por exemplo) e veja como isso muda seu dia a dia.</li><li><strong>Questione tudo</strong>: a IA erra, valide. Não confie cegamente.</li><li><strong>Treine bons prompts</strong>: isso é uma habilidade poderosa. Ser claro e iterar te leva longe.</li><li><strong>Volte aos fundamentos</strong>: entenda o que está sendo sugerido. Senão, você não está aprendendo.</li><li><strong>Documente o processo, não só a solução</strong>: isso ajuda o time inteiro a evoluir.</li><li><strong>Não se perca nas novidades</strong>: escolha bem suas ferramentas e aprofunde nelas.</li><li><strong>Pratique comunicação</strong>: se o futuro é conversar com IA, ser claro e preciso vira superpoder.</li></ul><h3>Pra fechar</h3><p>A IA está mudando muita coisa, mas não tudo. Ela é uma aliada poderosa, mas a reflexão, a empatia, a criatividade e a comunicação continuam sendo nossos maiores diferenciais.</p><p>Acredito que estamos no começo de uma era onde desenvolvedores que sabem navegar essa transição vão ser mais valiosos do que nunca. Não porque sabem todas as sintaxes de cor, mas porque conseguem traduzir problemas humanos complexos em soluções tecnológicas elegantes.</p><p>Se você também está navegando essa transição, compartilhe sua experiência também. Quanto mais abrirmos esse diálogo, mais preparados estaremos para o que vem por aí.</p><p>Valeu gente, e até a próxima! 😘</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a05e09d9aa30" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Escrevendo Códigos Flexíveis e Sustentáveis: Princípios SOLID em Java]]></title>
            <link>https://medium.com/@williamzampollo/escrevendo-c%C3%B3digos-flex%C3%ADveis-e-sustent%C3%A1veis-princ%C3%ADpios-solid-em-java-bf27c4f8d97a?source=rss-dc5eaf099119------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf27c4f8d97a</guid>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[flexibility]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[suitability]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[William Zampollo]]></dc:creator>
            <pubDate>Mon, 08 Apr 2024 20:45:13 GMT</pubDate>
            <atom:updated>2024-04-08T20:45:13.363Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Todo DEV já ouviu falar de SOLID, talvez até já tenham estudado isso lá na faculdade, mas será que todos entenderam de fato como funciona? Bora lá que vou tentar te explicar com a minha didática de centavos como essa parada funciona e quem sabe desta vez você entenda.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tfPFZWrRNnl4bXu7-CAjcg.jpeg" /></figure><blockquote><strong>Quem nunca pegou aquele código legado onde determinada classe só não fazia café por que acabou o pó?</strong></blockquote><p>Pois é, e em um mundo cada vez mais orientado a software, microsserviços, a qualidade do código é essencial para o sucesso de qualquer projeto. A manutenção, escalabilidade e flexibilidade de um sistema dependem diretamente da forma como o código é estruturado. É aqui que entram os <strong>Princípios SOLID.</strong></p><p>Esses princípios, propostos por<strong> Robert C. Martin</strong>, são um guia para escrever um <strong>código limpo, coeso e de fácil manutenção</strong>. Eles nos ajudam a criar sistemas robustos e flexíveis, permitindo que nossas aplicações evoluam com mais facilidade ao longo do tempo, e que não se tornem aquelas aplicações que quando você fala o nome, todo mundo se esconde para não ter que mexer nesse “vespeiro”.</p><p>Nesse artigo, falaremos um pouco cada um dos <strong>cinco princípios SOLID</strong> e veremos como aplicá-los em códigos <strong>Java</strong>. Através de exemplos práticos, e <strong><em>BEEEM simples, </em></strong>entenderemos por que esses princípios são tão importantes e como podem melhorar a qualidade do nosso código.</p><blockquote><em>Bora descobrir como construir softwares realmente “sólidos”!</em> 🚀</blockquote><h3>1. Princípio da Responsabilidade Única (SRP)</h3><p>O primeiro princípio é o <strong>SRP,</strong> e ele<strong> </strong>estabelece que uma classe deve ter uma única razão para mudar. Em outras palavras, uma classe deve ter apenas uma responsabilidade. Isso facilita demais a manutenção e evita que a classe se torne complexa e difícil de entender.</p><blockquote>Chega de classe polivalente.😁</blockquote><p><strong>Exemplo:</strong></p><pre>class PaymentProcessor {<br>    public void processPayment(Payment payment) {<br>        // Lógica para processar o pagamento<br>    }<br>}<br><br>class PaymentLogger {<br>    public void logPayment(Payment payment) {<br>        // Lógica para registrar informações de pagamento<br>    }<br>}</pre><p>Nesse exemplo, temos duas classes distintas, <strong>PaymentProcessor</strong> e <strong>PaymentLogger</strong>, cada uma com uma <strong>única </strong>responsabilidade.</p><p><strong>Como não fazer:</strong></p><pre>class PaymentHandler {<br>    public void processPayment(Payment payment) {<br>        // Lógica para processar o pagamento<br>        // Lógica para registrar informações de pagamento<br>    }<br>}</pre><p>Nesse exemplo, temos uma única classe <strong>PaymentHandler</strong> que realiza duas tarefas distintas, violando o princípio da responsabilidade única.</p><blockquote>O nome já diz tudo, <strong>Responsabilidade Única, </strong>se é única não tem como ter duas responsabilidades, não é mesmo meu querido(a)?</blockquote><h3>2. Princípio Aberto/Fechado (OCP)</h3><p>O segundo princípio é o <strong>OCP, </strong>ele prega que as entidades de software (classes, módulos, etc.) devem estar abertas para extensão, mas fechadas para modificação. Isso significa que, ao estender as funcionalidades do sistema, devemos ser capazes de fazer isso através de adição de novas classes ou módulos, em vez de alterar o código existente.</p><p><strong>Por exemplo:</strong></p><pre>interface Shape {<br>    double calculateArea();<br>}<br><br>class Circle implements Shape {<br>    private double radius;<br><br>    @Override<br>    public double calculateArea() {<br>        return Math.PI * radius * radius;<br>    }<br>}<br><br>class Rectangle implements Shape {<br>    private double width;<br>    private double height;<br><br>    @Override<br>    public double calculateArea() {<br>        return width * height;<br>    }<br>}</pre><p>Neste exemplo, o <strong>OCP </strong>é aplicado corretamente. Podemos adicionar novas formas (como quadrados, hexágonos, etc.) sem modificar o código existente. Basta criar uma nova classe que implemente a interface Shape.</p><p><strong>Como não fazer:</strong></p><p>Suponha que temos uma classe PaymentHandler que lida com pagamentos. Inicialmente, ela processa pagamentos com cartão de crédito:</p><pre>class PaymentHandler {<br>    public void processCreditCardPayment() {<br>        // Lógica para processar pagamento com cartão de crédito<br>    }<br>}</pre><p>Mais tarde, precisamos adicionar suporte para pagamentos via PayPal. A abordagem incorreta seria modificar a classe existente:</p><pre>class PaymentHandler {<br>    public void processCreditCardPayment() {<br>        // Lógica para processar pagamento com cartão de crédito<br>    }<br><br>    public void processPayPalPayment() {<br>        // Lógica para processar pagamento via PayPal<br>    }<br>}</pre><p>Isso viola o <strong>OCP</strong>, pois estamos modificando a classe original. Em vez disso, deveríamos criar uma nova classe (por exemplo, PayPalPaymentHandler) que estenda ou implemente uma interface comum (como PaymentProcessor). Dessa forma, podemos adicionar novos métodos de pagamento sem alterar a classe original.</p><p>Lembre-se de que o <strong>OCP </strong>visa manter o código flexível e extensível, permitindo adicionar novos comportamentos sem afetar o código existente. 🚀</p><h3>3. Princípio de Substituição de Liskov (LSP)</h3><p>O terceiro princípio é o <strong>LSP, </strong>que estabelece que as subclasses devem ser substituíveis por suas classes base sem afetar a consistência do programa. Em outras palavras, se uma classe base é substituída por uma subclasse, o comportamento do programa deve permanecer consistente e sem surpresas indesejadas.</p><p><strong>Por exemplo:</strong></p><pre>abstract class Forma {<br>     abstract int calcularArea();<br> }<br>    <br>class Retangulo extends Forma {<br>     protected int largura;<br>     protected int altura;<br>    <br>     public void setLargura(int largura) {<br>         this.largura = largura;<br>     }<br>    <br>     public void setAltura(int altura) {<br>         this.altura = altura;<br>     }<br>    <br>     @Override<br>     int calcularArea() {<br>         return largura * altura;<br>     }<br> }<br>    <br> class Quadrado extends Forma {<br>     protected int lado;<br>    <br>     public void setLado(int lado) {<br>         this.lado = lado;<br>     }<br>    <br>     @Override<br>     int calcularArea() {<br>         return lado * lado;<br>     }<br> }</pre><p>Neste exemplo, temos uma classe abstrata Forma, ela possui um método para calcularArea().As classes Retangulo e Quadrado herdam diretamente dessa classe abstrata, e cada uma implementa seu próprio método calcularArea() de acordo com suas características específicas.</p><p><strong>Como não fazer:</strong></p><pre> class Retangulo {<br>     protected int largura;<br>     protected int altura;<br>    <br>     public void setLargura(int largura) {<br>         this.largura = largura;<br>     }<br>    <br>     public void setAltura(int altura) {<br>         this.altura = altura;<br>     }<br>    <br>     public int calcularArea() {<br>         return largura * altura;<br>     }<br> }<br>    <br> class Quadrado extends Retangulo {<br>     public void setLado(int lado) {<br>         this.largura = lado;<br>         this.altura = lado;<br>     }<br> }</pre><p>Nesse exemplo, a classe Quadrado viola o Princípio da Substituição de Liskov, ao utilizar os atributos da classeRetangulo de uma forma que não é esperada. Quando o método setLado usa indevidamente o valor do lado no atributo altura.</p><blockquote>Esse tipo de código é bem comum entre os programadores mais preguiçosos🥱, na tentativa de reaproveitar código, pode inesperadamente nascer uma nova forma geométrica😂. <strong>Não façam isso!!</strong></blockquote><h3>4. Princípio da Segregação de Interfaces (ISP)</h3><p>O quarto princípio é o ISP, que diz que uma classe não deve ser forçada a implementar interfaces que não utiliza. Em vez disso, as interfaces devem ser específicas para os clientes que as utilizam.</p><p><strong>Por exemplo:</strong></p><pre>// Interface segregada para animais que podem voar<br>interface Voavel {<br>    void voar();<br>}<br><br>class Pato implements Voavel {<br>    @Override<br>    public void voar() {<br>        System.out.println(&quot;O pato está voando!&quot;);<br>    }<br>}<br><br>class Cachorro {<br>    // O cachorro não precisa implementar o método voar, logo ele não implementa a classe Voavel<br>}</pre><p>Nesse exemplo, temos interfaces separadas para Worker e Eater. As classes Robot e Human implementam apenas as interfaces relevantes para suas funcionalidades.</p><p><strong>Como não fazer:</strong></p><pre>// Interface incorreta com métodos desnecessários<br>interface Animal {<br>    void voar();<br>    void nadar();<br>    void correr();<br>}<br><br>class Pato implements Animal {<br>    @Override<br>    public void voar() {<br>        System.out.println(&quot;O pato está voando!&quot;);<br>    }<br><br>    @Override<br>    public void nadar() {<br>        System.out.println(&quot;O pato está nadando!&quot;);<br>    }<br><br>    @Override<br>    public void correr() {<br>        System.out.println(&quot;O pato está correndo!&quot;);<br>    }<br>}<br><br>class Cachorro implements Animal {<br>    @Override<br>    public void voar() {<br>        // Implementação desnecessária para o cachorro!<br>    }<br><br>    @Override<br>    public void nadar() {<br>        System.out.println(&quot;O cachorro está nadando!&quot;);<br>    }<br><br>    @Override<br>    public void correr() {<br>        System.out.println(&quot;O cachorro está correndo!&quot;);<br>    }<br>}</pre><p>Nesse exemplo incorreto, a interface Animal possui métodos desnecessários para o Cachorro, como voar(). Isso viola o ISP, pois o Cachorro é forçado a implementar um método que não faz sentido para ele.</p><blockquote>Lembre-se sempre de manter suas interfaces coesas e com apenas o mínimo necessário para seus clientes, evitando interfaces “inchadas” e garantindo um design mais flexível e sustentável.</blockquote><h3>5. Princípio da Inversão de Dependência (DIP)</h3><p>Por último mas não menos importante, temos o DIP, este principio nos diz que sistemas mais flexiveis são aqueles que possuem dependências de código fonte que apontam para abstrações e nunca para coisas concretas.</p><p><strong>Por exemplo:</strong></p><pre>// Interface para o serviço de envio de e-mails<br>interface EnviadorEmail {<br>    void enviar(String destinatario, String mensagem);<br>}<br><br>// Implementação concreta do serviço de envio de e-mails<br>class ServicoEmail implements EnviadorEmail {<br>    @Override<br>    public void enviar(String destinatario, String mensagem) {<br>        // Lógica para enviar o e-mail<br>        System.out.println(&quot;E-mail enviado para &quot; + destinatario + &quot;: &quot; + mensagem);<br>    }<br>}<br><br>// Classe que depende do serviço de envio de e-mails<br>class Cliente {<br>    private final EnviadorEmail enviador;<br><br>    public Cliente(EnviadorEmail enviador) {<br>        this.enviador = enviador;<br>    }<br><br>    public void enviarMensagem(String destinatario, String mensagem) {<br>        enviador.enviar(destinatario, mensagem);<br>    }<br>}</pre><p>Neste exemplo, utilizamos interfaces para criar abstrações e garantir que os módulos de alto nível dependam apenas dessas abstrações. O Cliente depende apenas da abstração EnviadorEmail, permitindo que diferentes implementações (por exemplo, envio via SMTP, envio via API, etc.) sejam facilmente trocadas.</p><p><strong>Como não fazer:</strong></p><pre>class Motor {<br>    public void ligar() {<br>        // Implementação para ligar o motor<br>    }<br>}<br><br>class Carro {<br>    private final Motor motor;<br><br>    public Carro() {<br>        this.motor = new Motor(); // Violação do DIP<br>    }<br><br>    public void ligarCarro() {<br>        motor.ligar();<br>    }<br>}</pre><p>Neste exemplo, a classe Carro cria uma instância direta da classe Motor, violando o DIP. A classe Carro está diretamente acoplada à implementação concreta do Motor. Isso dificulta a substituição ou extensão do comportamento do motor.</p><h3>Conclusão</h3><p>Esses exemplos ilustram como aplicar os Princípios SOLID em alguns casos simples para efeito de entendimento do conteúdo, mas não se engane, usando corretamente esses princípios, conseguimos criar códigos muito bem escritos, e na hora de dar manutenção, não será aquele “Deus nos acuda”.</p><blockquote>Lembre-se de que a prática constante e a adaptação desses princípios aos contextos específicos são essenciais para escrever código de qualidade. 🚀</blockquote><p>Valeu gente, e até a próxima! 😘</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf27c4f8d97a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>