<?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 Amanda Moraes on Medium]]></title>
        <description><![CDATA[Stories by Amanda Moraes on Medium]]></description>
        <link>https://medium.com/@a.bmoraes.ti?source=rss-b50a0580c69a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*NjIySkuLXoC0n5wAY3P1_A.jpeg</url>
            <title>Stories by Amanda Moraes on Medium</title>
            <link>https://medium.com/@a.bmoraes.ti?source=rss-b50a0580c69a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 23:21:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@a.bmoraes.ti/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[Design Pattern: Como você está construindo objetos complexos?]]></title>
            <link>https://medium.com/lets-code-brasil/design-patterns-como-voc%C3%AA-est%C3%A1-construindo-objetos-complexos-11dc94c8b20d?source=rss-b50a0580c69a------2</link>
            <guid isPermaLink="false">https://medium.com/p/11dc94c8b20d</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[builder-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <dc:creator><![CDATA[Amanda Moraes]]></dc:creator>
            <pubDate>Sun, 14 Jun 2020 02:20:17 GMT</pubDate>
            <atom:updated>2020-06-15T03:40:07.550Z</atom:updated>
            <content:encoded><![CDATA[<h3>Design Patterns: como você está construindo objetos complexos?</h3><figure><img alt="Uma imagem com fundo preto e frase em branco dizendo “Think twice, code once”" src="https://cdn-images-1.medium.com/max/1024/1*ATKz7GCv2rHq0Q_SDwRW4A.jpeg" /></figure><p>Os prazos estão encurtando. Precisamos ser mais ágeis. E mesmo quando só precisamos adicionar um contexto diferente para uma funcionalidade parecida, a atuação no código continua demorada e a reutilização da solução não pode ser trabalhada da melhor forma possível. E aquele código difícil de entender pra quem está chegando? Pois é. Ás vezes até erros ocorrem, ou mesmo a performance é afetada.</p><p>No fim, a experiência nos faz perceber que esses mesmos problemas aparecem com frequência, em mais sistemas, com mais desenvolvedores e a importância de se utilizar melhores práticas acaba entrando em foco. Então já que esses problemas são recorrentes, porque não padronizamos as soluções e disseminamos à comunidade?</p><figure><img alt="Nuvem de palavras que referem-se a padrões de projetos como por exemplo: Observer, Singleton, Adapter, Builder, etc." src="https://cdn-images-1.medium.com/max/997/1*Wq7NM8hE8y4qNAbCKB3MeA.png" /></figure><p>Em 1995, um grupo de 4 pessoas conhecidos como <strong>Gang of Four</strong> (GOF): Rich Gamma, Richard Helm, Ralph Johnson e John Vlissides; fizeram isso. Eles publicaram o livro <strong>Design Patterns: Elements of Reusable Object</strong> para propor a comunidade padrões de projeto que podem contribuir no melhor uso da programação orientada a objetos. Isso aumenta a velocidade de desenvolvimento, torna a manutenção do código mais viável e modular.</p><p>Logo, o conhecimento desses padrões é importante para entender o que eles podem ajudar no sistema quando for o caso. E dentre os padrões existentes, vou abordar nesse artigo um que tem papel importante na criação de objetos complexos. Esse padrão é o <strong>Builder</strong>.</p><h4>Então, vamos falar sobre o Builder!</h4><figure><img alt="GIF do desenho “Bob, the buider” com o personagem martelando a fim de realizar a construção desejada." src="https://cdn-images-1.medium.com/max/220/0*gRAD46u1aP1j5cm9.gif" /></figure><p>Uma classe pode permitir várias representações de objeto. E para construí-los nesse contexto, é comum definirmos um construtor com <strong>vários parâmetros</strong> de entrada, que muitas vezes uns são <strong>inúteis </strong>em algumas representações e precisam ser preenchidos com valores <em>default</em>.</p><p>Ainda para solucionar o problema anterior, acabamos definindo <strong>vários construtores</strong> para adaptarmos parâmetros diferentes, o que as vezes pode confundir o desenvolvedor sobre qual usar.</p><p>Com base nisso, surge o padrão <strong>Builder </strong>como <strong>padrão de criação</strong>. Cujo objetivo é…</p><blockquote>…separar a construção de um objeto complexo de sua representação para que o mesmo processo de construção possa criar representações diferentes.</blockquote><blockquote>- Gang of Four</blockquote><p>Além da criação de representações diferentes de um mesmo objeto, implementá-lo ajuda também na questão de manter a complexidade sob controle, pois classes com muitas tarefas são mais difíceis de entender dificultando na manutenção e evolução do sistema. A lógica assim da criação do objeto fica apartada, dedicando a responsabilidade a classes específicas, mantendo alta coesão e modularidade.</p><p>Normalmente, no padrão Builder temos os seguintes tipos de classes:</p><ul><li>A interface ou classe abstrata builder;</li><li>A classe de implementação da interface builder para a criação das partes do objeto;</li><li>O director (diretor) que chama os métodos do builder para gerar o objeto final;</li><li>E o product (produto), que representa o objeto.</li></ul><p>Segue o diagrama <strong>UML</strong> dessas classes conforme apresentado no livro da <strong>GoF</strong>:</p><figure><img alt="Diagrama do Builder representando de forma visual a descrição de todas as classes anteriormente mencionadas conectadas." src="https://cdn-images-1.medium.com/max/567/1*iKvphQ64g4xVfO6rSqxpwQ.png" /><figcaption>Diagrama UML do Builder</figcaption></figure><p>A seguinte estrutura apresentada pelo <strong><em>refactoring.guru</em></strong> detalha mais essas classes e mostra como se dá na construção do objeto:</p><figure><img alt="Estrutura com classes mencionadas, expondo detalhes de métodos que podem ser aplicados em cada assim como exemplo." src="https://cdn-images-1.medium.com/max/470/0*1H2zXi-fWmQ7o0eW.png" /><figcaption>Estrutura Detalhada do Builder</figcaption></figure><h4>Let’s Code!</h4><p>O exemplo que vou abordar é um projeto console desenvolvido em <strong>C#</strong> para a construção de labirintos que varia conforme nível de dificuldade desejado. Para tanto, começamos com a classe abstrata do Builder (que poderia ser adotado também interface nesse caso):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c58cc277a223f57e25acfbdd7b2723d5/href">https://medium.com/media/c58cc277a223f57e25acfbdd7b2723d5/href</a></iframe><p>Nela definimos todos os passos que serão implementados nas diferentes representações do Labirinto. Implementei então com base nessa classe, o Labirinto Padrão (classe LabirintoPadraoBuilder):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/13545dad5df38e9e4739c2a31c318c77/href">https://medium.com/media/13545dad5df38e9e4739c2a31c318c77/href</a></iframe><p>E o Labirinto Difícil (classe LabirintoDíficilBuilder):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0b7b7e3b418e77956991c89a5a23cab8/href">https://medium.com/media/0b7b7e3b418e77956991c89a5a23cab8/href</a></iframe><p>Veja que essas classes podem ser facilmente modificadas para novas configurações desses labirintos. Além de ser possível adicionar um novo builder para outra representação futuramente.</p><p>Segue a classe Labirinto com os atributos definidos e um método para exibição desses valores:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b45955d46acf99a4b14aaa78e365553/href">https://medium.com/media/8b45955d46acf99a4b14aaa78e365553/href</a></iframe><p>Na classe Director foi definido um método de construção que passa pelas etapas de criação do builder desse objeto.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a8887256d647f7fb4246d56664812b89/href">https://medium.com/media/a8887256d647f7fb4246d56664812b89/href</a></iframe><p>E para vermos funcionando, construí os dois labirintos no método main exibindo seus valores ao final:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c1bac9b6c2065367273bd58488a99933/href">https://medium.com/media/c1bac9b6c2065367273bd58488a99933/href</a></iframe><p>Segue a saída no console:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7hiOUtHNiLtDK4-ToV5JSg.png" /></figure><p>Caso a saída seja diferente para as representações desse objeto, esse método pode ser implementado também no builder. Mas a ideia no geral é isolar a lógica de criação dos objetos das regras de negócio do sistema. E tornar a construção mais reutilizada também.</p><p>Há alguns exemplos atualmente na comunidade que não utilizam o Director, sendo chamados diretamente os métodos dos Builders para a construção desses objetos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9ef9d9d5312e721b953a136c3436d283/href">https://medium.com/media/9ef9d9d5312e721b953a136c3436d283/href</a></iframe><p>Esse encadeamento é possível pois cada método retorna a própria classe builder referida. Essa versão do Builder foi proposta por Joshua Bloch na segunda edição do livro <a href="https://www.pearson.com/us/higher-education/program/Bloch-Effective-Java-2nd-Edition/PGM310651.html">Effective Java</a>.</p><p>Bom, ficamos por aqui. Até a próxima!</p><p>Os exemplos apresentados podem ser acessados no meu GitHub pelo seguinte link:</p><p><a href="https://github.com/abmoraes16/DesignPatterns">abmoraes16/DesignPatterns</a></p><h3>Referências</h3><p>Design Patterns: Elements of Reusable Object-Oriented Software. Por Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.</p><p>Refactoring Guru: Builder. <a href="https://refactoring.guru/design-patterns/builder">https://refactoring.guru/design-patterns/builder</a>.</p><p>Engenharia de Software Moderna: 6- Padrões de Projeto. <a href="https://engsoftmoderna.info/cap6.html">https://engsoftmoderna.info/cap6.html</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11dc94c8b20d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-code-brasil/design-patterns-como-voc%C3%AA-est%C3%A1-construindo-objetos-complexos-11dc94c8b20d">Design Pattern: Como você está construindo objetos complexos?</a> was originally published in <a href="https://medium.com/lets-code-brasil">Let’s code Brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>