<?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 Marcos Douglas B. Santos on Medium]]></title>
        <description><![CDATA[Stories by Marcos Douglas B. Santos on Medium]]></description>
        <link>https://medium.com/@mdbs99?source=rss-6b9a93dfd800------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*NjTJ1aT90AhaSmr1JOeXNg.png</url>
            <title>Stories by Marcos Douglas B. Santos on Medium</title>
            <link>https://medium.com/@mdbs99?source=rss-6b9a93dfd800------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:00:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mdbs99/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[Procedural é fácil, Orientado a Objetos é difícil]]></title>
            <link>https://medium.com/@mdbs99/procedural-%C3%A9-f%C3%A1cil-orientado-a-objetos-%C3%A9-dif%C3%ADcil-9243f32df179?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/9243f32df179</guid>
            <category><![CDATA[brazil]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[object-pascal]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[opportunity]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Sun, 15 Jan 2017 23:59:39 GMT</pubDate>
            <atom:updated>2017-01-15T23:59:39.580Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*ySTySEgv2gDNwCVD.jpg" /></figure><p>Por que ainda temos discussões sobre a Programação Procedural ser mais fácil do que a Programação Orientada a Objetos? É claro que Programar no paradigma Procedural é mais fácil.</p><p>Você olha para um código com 5 instâncias de Objetos, agumentos de Construtores, consumo de memória, polimorfismo e pensa:</p><p><strong>Eu poderia fazer a mesma coisa com 10 linhas de código Procedural.</strong></p><p>A performance — você diria — poderia ser melhor, iria consumir menos memória e, claro, é muito mais fácil codificar.</p><p>Eu concordo… em parte.</p><p>Então por que escolher a <a href="http://objectpascalprogramming.com/posts/o-que-e-orientacao-a-objetos/">Orientação a Objetos</a>?</p><p>Por que fazer da maneira “mais difícil”?</p><p>Por que criar um <a href="https://en.wikipedia.org/wiki/Overhead_(computing)"><em>overhead</em></a> “desnecessário”?</p><p>Se pensarmos apenas no <em>overhead</em> que traz a Orientação a Objetos, vamos então codificar nossos sistemas em apenas um único arquivo, usando <em>GO TO</em> e código ASSEMBLY.</p><p>Orientação a Objetos é sobre <strong>manutenabilidade</strong> no longo prazo.</p><p>É sobre não pensar como um controlador ou CPU, mas como <a href="http://objectpascalprogramming.com/posts/objetos-representam-entidades/">Entidades</a> auto-suficientes que <a href="http://objectpascalprogramming.com/posts/objetos-pensam-e-tomam-decisoes/">pensam e tomam decisões</a> por conta própria.</p><p>Não é sobre estar certo ou errado, fazer diagramas bonitos ou porque fica legal por no Currículo.</p><p><strong>Orientação a Objetos é sobre resolver um problema de forma sustentável.</strong></p><p>Por isso escolhemos desenvolver seguindo esse paradigma.</p><p>Em 1 hora é possível fazer muita coisa de forma Procedural, enquanto na Orientação a Objetos podemos ficar 1 hora apenas tentando identificar o melhor <a href="http://objectpascalprogramming.com/posts/nomeando-classes/">nome para uma Classe</a>, quais são as <a href="http://objectpascalprogramming.com/posts/objetos-representam-entidades/">Entidades</a> que fazem parte do problema, quais os Contextos…</p><p>E se eu lhe dissesse que podemos ficar “apenas” <a href="http://objectpascalprogramming.com/posts/pensando-em-objetos/">pensando</a> por 1 ou 2 semanas, sem escrever nenhuma linha de código?</p><p>É verdade, acontece.</p><p>Não adianta fazer um sistema rapidamente se seu código não é <strong>sustentável</strong> no longo prazo.</p><p><em>Softwares</em> sempre <strong>mudam</strong>.</p><p><strong>Orientação a Objetos é sobre organização.</strong></p><p>Nós passamos a maior parte do tempo não codificando novas <em>features</em>, mas sim lendo e tentando entender o código.</p><p>De que adianta ter um código de execução mais rápida em 100 ms se daqui a um mês ninguém sabe como alterá-lo?</p><p>Orientação a Objetos não é mais difícil de codificar, é apenas é mais trabalhoso.</p><p><strong>Mas vale a pena.</strong></p><p>Por que no fim você irá trabalhar menos.</p><p>Talvez com um pouco mais de código, é verdade, mas terá menos <em>bugs</em>.</p><p>Menos <em>debugging</em>.</p><p>Menos problemas.</p><p>Orientação a Objetos agrega <strong>qualidade</strong>.</p><p>E qualidade, é o que mais importa.</p><p>Até logo.</p><p><em>Originally published at </em><a href="http://objectpascalprogramming.com/posts/procedural-e-facil-orientado-a-objetos-e-dificil/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9243f32df179" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Classes de Dados]]></title>
            <link>https://medium.com/@mdbs99/classes-de-dados-4cffa3a659a7?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cffa3a659a7</guid>
            <category><![CDATA[object-pascal]]></category>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[pop]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Thu, 01 Dec 2016 18:17:09 GMT</pubDate>
            <atom:updated>2016-12-01T18:17:09.415Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*e1aEfjOxC0NFQEkQ.jpg" /></figure><p>Objetos são constituídos de Estado e Comportamento, enviam mensagens uns aos outros e devem representar Entidades reais de tudo que existe fora do Contexto do Software.</p><p>E os Dados, onde estão os Dados?</p><h3>Introdução</h3><p>Tenho dito, por várias vezes, que um Objeto não deve ser visto ou utilizado como um <a href="http://objectpascalprogramming.com/posts/o-que-e-orientacao-a-objetos/#objeto-nao-e-um-balde-de-funcoes-e-dados">balde de dados e funções</a>.</p><p>Objetos não são <a href="http://objectpascalprogramming.com/posts/datamodule-e-apenas-um-container/"><em>containers</em></a> de transporte de dados. Eles devem <a href="http://objectpascalprogramming.com/posts/objetos-representam-entidades/">representar uma Entidade</a> fora do Contexto do Software. Não importa se a Entidade é um objeto, pessoa ou Dados.</p><p>E o que são Dados?</p><p>É difícil definir a diferença entre Dados e o Estado de um Objeto. Ambos, tecnicamente, podem ser considerados Dados. No entanto, eu acredito, há uma diferença teórica entre eles que muda nosso <strong>modo de pensar</strong> quando estamos construindo um <em>software</em> Orientado a Objetos.</p><blockquote><em>Dados também são representados por Objetos, pois eles também estão fora do Contexto do Software.</em></blockquote><p>Mas como um Objeto não deve ser um “balde de dados” e ao mesmo tempo deve representar Dados?</p><h3>Dados e Estado</h3><p>Tudo são Objetos.</p><p>Tudo deve ser representado por Objetos.</p><p>Não há diferenças, pensando em termos de Objetos, entre um <strong>Carro</strong> e o <strong>número 9</strong>, por exemplo. Ambos são Entidades que deveriam ser representados dentro do <em>software</em> por Objetos.</p><p>Mas a vida é difícil. Desenvolver <em>software</em> Orientado a Objetos de forma <em>perfeita</em> é quase impossível. Precisamos pensar na performance, na alocação de memória, uso de recursos, etc. E aí começa a confusão entre Dados e Estado.</p><p>Vejamos. Se tenho uma Classe TUrl com uma propriedade privada FValue: string, a propriedade é um <strong>Dado</strong> ou o <strong>Estado</strong> do Objeto?</p><p>Eu diria que representa o Estado do Objeto. A propriedade FValue é a URL em forma de string.</p><p>Mas como string é um tipo primitivo (no Pascal), pensamos em termos de Dados e não de Estado do Objeto.</p><p>Vejamos outro exemplo:</p><pre>type<br>  TFile = class(TInterfacedObject, IFile)<br>  private<br>    FPath: string;<br>    FName: string;<br>    FStream: IDataStream;<br>  public<br>    constructor Create(const Path, Name: string; <br>      Stream: IDataStream);<br>    function Path: string;<br>    function Name: string;<br>    function Stream: IDataStream; <br>  end;</pre><p>No exemplo acima, tem diferença entre Dados e Estado?</p><p>Sim.</p><p>Todas as 3 propriedades fazem parte do Estado do Objeto, no entanto a propriedade FStream representa os Dados do arquivo que estão no HD do computador.</p><p>A Classe TFile faz uso da Composição de Objetos. Não olhamos para TFile como um <em>container</em> de <em>bytes</em>, mas como um Objeto que representa um Arquivo no computador.</p><p>Mas, se olharmos apenas para o Objeto FStream dentro de TFile, ele poderia ser implementado assim:</p><pre>type<br>  TDataStream = class sealed(TInterfacedObject, IDataStream)<br>  private<br>    FStream: TMemoryStream;<br>  public<br>    constructor Create(Stream: TStream);<br>    destructor Destroy; override;<br>    procedure Save(Stream: TStream); overload;<br>    procedure Save(const FileName: string); overload;<br>    function Size: Int64;<br>  end;</pre><p>Agora o Contexto mudou.</p><p>A propriedade FStream na Classe TDataStream representa o Estado do Objeto e não Dados do Objeto. Essa Classe representa um <em>stream</em> mas ela não sabe se o <em>stream</em> é proveniente de um Arquivo ou de registros em uma Tabela.</p><p>Estamos olhando para um novo Contexto e isso muda nossa percepção sobre o que é ou não Dados.</p><p>Veja que internamente TDataStream foi implementado utilizando um TMemoryStream para “guardar” o <em>stream</em> — mais uma vez utilizando Composição de Objetos — mas eu poderia optar por utilizar apenas <em>bytes</em> e um ponteiro para a memória. Não importa. Isso tudo é privado e ninguém sabe o que acontece dentro de um Objeto. O importante é saber distinguir a diferença entre Dados e Estado do Objeto.</p><h3>Dados na forma de Objetos</h3><p>Classes de Dados são aquelas que geram Objetos que representam Dados.</p><p>Nós utilizamos Dados na forma de Objetos a muito tempo.</p><p>Uma Classe TJsonObject representa um <em>stream</em> de JSON, assim como uma Classe TXmlDocument representa um <em>stream</em> de XML.</p><p>Se não tivéssemos essas Classes, teríamos que trabalhar os Dados no nível de <em>bytes</em> e ponteiros na memória. Programação Procedural.</p><p>Queremos utilizar Objetos, pois eles facilitam nossas vidas. Então encapsulamos arquivos, <em>streams</em>, registros de Tabelas, etc em Classes que geram Objetos para manipular os Dados.</p><h3>Conclusão</h3><p>Não há problema se seu Objeto encapsula apenas Dados, contanto que esses Dados fazem parte da Entidade real que seu Objeto está representando.</p><p>Entender a sutil diferença entre Dados e Estado do Objeto irá fazer você codificar Classes melhores.</p><p>Você não irá mais pensar em definir uma única Classe que encapsula todos os Dados, mas sim Classes que representam Entidades, que utilizam a Composição de Objetos para Encapsular outros Objetos que, por fim, irão representar os Dados.</p><p>Até logo.</p><p><em>Originally published at </em><a href="http://objectpascalprogramming.com/posts/classes-de-dados/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cffa3a659a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Objetos Imutáveis]]></title>
            <link>https://medium.com/@mdbs99/objetos-imut%C3%A1veis-3de5d44bccd9?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/3de5d44bccd9</guid>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[delphi]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[object-pascal]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Tue, 18 Oct 2016 11:32:05 GMT</pubDate>
            <atom:updated>2016-10-18T11:32:05.051Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/933/0*gRji3-4GQCTG_rjs.jpg" /></figure><p>Objetos Imutáveis são seguros, são <em>thread-safe</em>, simples de entender, construir e testar. Evitam acoplamento temporal, previnem a referencia nil/NULL e não precisam utilizar “cópia defensiva”.</p><h3>Introdução</h3><p>Um <a href="https://en.wikipedia.org/wiki/Immutable_object">Objeto Imutável</a> é uma instância que, após inicializada através do <a href="http://objectpascalprogramming.com/posts/construtores-da-classe-primario-secundarios/">construtor</a> de sua Classe, nunca terá seu Estado alterado para o mundo exterior até o fim de sua vida.</p><p>Se você está lendo isso pela primeira vez talvez não consiga visualizar os benefícios das <strong>restrições</strong> que a Imutabilidade traz ao Desenvolvimento de Software.</p><p>Sim, restrições, e isso é ótimo.</p><blockquote><em>Objetos Imutáveis são livres de efeitos colaterais externos. Eles são criados representando um momento específico no tempo e devem permanecer inalterados até a sua morte. eBook — @ObjectPascalProgramming</em></blockquote><p>A Imutabilidade irá lhe ajudar a <strong>codificar melhor</strong>, muito melhor, devido as restrições impostas.</p><p>Você terá que pensar cuidadosamente em suas Classes, porque elas existem, qual o real trabalho delas… Seus Objetos serão imutáveis então você não poderá alterar o comportamento deles em <em>runtime</em> utilizando <a href="http://objectpascalprogramming.com/posts/getters-e-setters/"><em>Setters</em></a>. Consequentemente cada Objeto deverá ter uma <strong>construção simples</strong> e fazer apenas um único trabalho. Os argumentos desse trabalho só poderão ser informados no construtor e ninguém quer um construtor complexo com 10 parâmetros, certo?</p><p>Por causa da Imutabilidade você será obrigado a fazer as Classes com poucos métodos e poucos argumentos no construtor.</p><p>Imutabilidade nos faz ter <strong>disciplina</strong> para codificar.</p><h3>Vantagens da Imutabilidade</h3><p>Restrições são ótimas para o código. Restrições, limites, condições… tudo isso traz ordem, clareza e entendimento.</p><p>Se você restringir, terá menos coisas para se preocupar, cuidar, modificar e testar.</p><p>Além da disciplina, vejamos algumas outras vantagens em utilizarmos a Imutabilidade.</p><h3>1-Segurança</h3><p>Objetos Imutáveis são seguros. Se o construtor de uma Classe retornar para o seu programa uma instância de um Objeto Imutável, significa que essa instância é segura para usar. Tudo o que deveria ter sido inicializado nessa instância que dependia do mundo externo, já foi verificado e satisfeito. Não é necessário utilizar nenhum outro Setter. Não há mais dependências externas. Tudo está pronto. Nada poderá ser quebrado.</p><h3>2-Thread-safe</h3><p>Objetos Imutáveis são <em>thread-safe</em> por definição. Se seu estado não modifica, seu Objeto pode ser compartilhado por mais de uma <em>thread</em>, ao mesmo tempo, sem necessidade de sincronismos. Isso nos traz performance. Não há necessidade de <em>lock</em> nas threads. A informação irá fluir com segurança e rapidez.</p><h3>3-Simples de Entender, Construir e Testar</h3><p>Objetos Imutáveis só recebem seus argumentos no construtor da Classe. Não queremos 10 ou mais argumentos para iniciar um Objeto. No máximo deveríamos utilizar 5 argumentos — é a regra que tento seguir.</p><p>Se uma Classe não tem modificadores externos e os construtores tem apenas 5 ou menos argumentos, então o Objeto será:</p><ol><li>Simples de entender porque terá menos código para ler (toda a dependência externa estará apenas no construtor);</li><li>Fácil de construir por possuir poucos argumentos (lembre-se: 5 no máximo);</li><li>Fácil de testar porque o único ponto de variação do comportamento são os argumentos (trate-os em Testes de Unidade e terá coberto todas as possibilidades de comportamento que o Objeto poderá ter).</li></ol><p><a href="http://objectpascalprogramming.com/posts/objetos-imutaveis/#acoplamento-temporal">Continue lendo…</a></p><p><em>Originally published at </em><a href="http://objectpascalprogramming.com/posts/objetos-imutaveis/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3de5d44bccd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Métodos Getters e Setters]]></title>
            <link>https://medium.com/@mdbs99/m%C3%A9todos-getters-e-setters-ce03649731b?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce03649731b</guid>
            <category><![CDATA[delphi]]></category>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[object-pascal]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Mon, 04 Jul 2016 19:59:44 GMT</pubDate>
            <atom:updated>2016-07-04T19:59:44.923Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Z4CEzHjIIlnB2-2V.jpg" /></figure><p>Seus Objetos representam alguma Entidade real ou são apenas um “balde de dados e funções”? Classes que possuem somente métodos Get/Set não geram Objetos reais seguindo o real conceito da Orientação a Objetos.</p><h3>Introdução</h3><p>Os Objetos devem ter métodos para interagir com o mundo exterior. Esses métodos podem executar ações e retornar outros Objetos. No entanto o mundo exterior não deveria ter o conhecimento se os Objetos ou valores retornados nesses métodos fazem ou não parte do Estado interno dos Objetos.</p><blockquote><em>Ao projetar com cuidado e se concentrar no que você deve fazer ao invés de como você vai fazer, elimina a grande maioria dos métodos getters/setters em seu programa. — Why getter and setter methods are evil, JavaWorld</em></blockquote><p>Muitos programadores não entendem ou ignoram esse conceito.</p><p>Um Objeto não deve representar um <a href="http://objectpascalprogramming.com/posts/o-que-e-orientacao-a-objetos/#objeto-nao-e-um-balde-de-funcoes-e-dados">registro numa tabela</a>, mas sim <a href="http://objectpascalprogramming.com/posts/objetos-representam-entidades/">Entidades</a> exteriores ao sistema no qual o Objeto foi criado.</p><h3>Métodos Getters</h3><p>Os métodos Getters são, conceituamente, mal entendidos e erroneamente utilizados. Por exemplo. Se você tem um método GetName, público, que retorna um atributo FName: string que faz parte do Estado do Objeto, conceitualmente falando, fica <strong>explícito</strong> para o mundo exterior que informações internas do Objeto estão sendo retornadas apenas porque estamos utilizando o prefixo Get.</p><p>Essa é uma forma de <a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-2/#encapsulamento">Violação de Encapsulamento</a>. No entanto é uma <strong>violação teórica</strong>, baseada apenas na intenção da nomenclatura escolhida para o método.</p><p>Repito. É uma violação <strong>teórica</strong>. Isso quer dizer que não tem efeito prático em utilizar ou não o prefixo Get. Mas estou falando de intenção, ou seja, qual será o trabalho do método. Usar Get como prefixo dá a entender que <strong>algo interno será dado a quem pede</strong>. E isso não é bom.</p><p>Mas a linguagem <em>Object Pascal</em> tem <em>properties</em> — o mesmo conceito copiado para C# :) — e não precisamos utilizar métodos Get, encapsulando do mundo exterior como a informação será processada antes de ser retornada. Pode vir de um método Get privado ou diretamente do atributo. Ponto positivo para o <em>Object Pascal</em>.</p><h3>Métodos Setters</h3><p>Bem, se deixar o mundo exterior bisbilhotar dentro de um Objeto utilizando seus métodos Getters públicos para obter todo o seu Estado interno é ruim, imagine então permitir alterações no Estado desse Objeto utilizando métodos Setters.</p><blockquote><em>Um Objeto não pode ter seu estado interno alterado, pois isso entraria em conflito com a realidade da Entidade na qual ele representa. eBook — @ObjectPascalProgramming</em></blockquote><p>Objetos devem ser Imutáveis.</p><p>Objetos Imutáveis são livres de efeitos colaterais externos. Eles são criados representando um momento específico no tempo e devem permanecer inalterados até a sua morte.</p><p>Esse é um conceito muito menos abstrato do que a violação de encapsulamento utilizando Getters, mas pode ser ainda mais difícil de entender. E é por isso que terei que falar sobre imutabilidade em outro artigo.</p><h3>Conclusão</h3><p>Esse artigo serve para lembrá-lo que codificar Classes que representam registros em tabelas não é Orientação a Objetos.</p><p>Métodos Getters públicos não são necessários.</p><p>Métodos Setters ou <em>properties</em> que podem ser alteradas devem ser evitadas a todo custo. Nem todo Objeto pode ser imutável, infelizmente. Objetos <em>widgets</em>, por exemplo, serão mutáveis por conveniência e performance. Mas tente manter seus Objetos de Negócio imutáveis.</p><p>Podemos remover ambos, Getters/Setters, de nossos sistemas Orientado a Objetos quase por completo. Classes imutáveis não tem Setters e para Getters o Objeto deve passar a informação <strong>ele mesmo</strong> e não <strong>alguém pegar a informação</strong> dele. Falarei sobre isso futuramente.</p><p>Se você não precisasse de métodos Setters e utilizar Getters é no mínimo duvidoso, simplifique utilizando somente funções.</p><p>Como sempre faço uso de <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Interfaces</a>, eu nunca implemento <em>properties</em> porque seria obrigado a declarar seus métodos de leitura/escrita, ou seja, Get/Set. Esses métodos poderiam ser privados, é claro, mas essa verbosidade é desnecessária se você estiver utilizando Objetos imutáveis.</p><p>Você acha que sou o único a pensar dessa maneira? Bem, então <a href="http://www.javaworld.com/article/2073723/core-java/why-getter-and-setter-methods-are-evil.html">aqui está</a> um ótimo artigo que fala sobre o assunto. Foi dele que traduzi a citação no início do artigo. E se quiser mais um, <a href="http://www.yegor256.com/2014/09/16/getters-and-setters-are-evil.html">aqui está</a>. Boa leitura.</p><p>Até logo.</p><p><em>Originalmente publicado em </em><a href="http://objectpascalprogramming.com/posts/getters-e-setters/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce03649731b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Herança pode ser o Mal da Orientação a Objetos — Parte Final]]></title>
            <link>https://medium.com/@mdbs99/heran%C3%A7a-pode-ser-o-mal-da-orienta%C3%A7%C3%A3o-a-objetos-parte-final-d0c6b4b2b9f5?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0c6b4b2b9f5</guid>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[delphi]]></category>
            <category><![CDATA[object-pascal]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Sat, 02 Jul 2016 16:04:33 GMT</pubDate>
            <atom:updated>2016-07-02T16:04:33.121Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/986/0*dq4OYQyqIXp8JE8s.jpg" /></figure><p>No artigo anterior falei sobre Forte Acoplamento. Nesse artigo irei falar sobre <strong>Hierarquias Complexas</strong> e concluir a série.</p><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-4/">Clique aqui</a> para ler a <strong>Parte #4</strong> dessa série, caso ainda não tenha lido.</p><h3>Introdução</h3><p>A maioria dos desenvolvedores esqueceram ou nunca aprenderam que a Herança foi feita para proporcionar o Polimorfismo e não para reutilizar código.</p><p>O reuso de código é apenas um “efeito colateral” da Herança.</p><p>Polimorfismo é importante e em linguagens como C++, por exemplo, a única maneira de implementarmos Polimorfismo é através da Herança de Classes. A linguagem C++ não tem Interfaces, sendo Herança de Classe uma escolha correta.</p><p>Arquitetos de linguagens de programação vem copiando as ideias de outras linguagens a muito tempo. Se uma linguagem nova for muito diferente das mais populares, corre o risco de nunca ter um público que as utilize. Então, por que não copiar caracteristicas de outras linguagens que já fazem sucesso?</p><p>Se C++ tem Herança de Classes, porque não ter em Java, Ruby, Object Pascal… os programadores já estão acostumados, então vamos implementar essa característica também.</p><p>Imagino que seja assim ao criar uma nova linguagem. Mas nem sempre. As linguagens funcionais são bem diferentes das imperativas. A Go Language, por exemplo, não é funcional mas também não implementa Herança — mas parece uma nova cópia da liguagem C, não?</p><p>Então, cada nova linguagem deve ter alguma referência anterior para não ser completamente alienígena. Pra mim, esse é o maior motivo de ainda termos Herança de Classes nas novas linguagens.</p><p>Se você programa em Object Pascal, no entanto, já tem o suporte a <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Interfaces</a>, que é uma melhor opção para implementar Polimorfismo do que utilizar Herança de Classes. Se podemos implementar o Polimorfismo através de Interfaces e reutilizar código através da Composição de Objetos e delegação, por que iríamos limitar nossas Classes a herdar de uma única hierarquia rígida de Classes?</p><p>Não faz sentido.</p><p>Por que uma Classe Gato deveria herdar de Animal, Mamífero ou quadrúpede se o sistema só precisa conhecer um Gato? Essas implementações de Super Classes, muitas vezes, <a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-3/#solucao">nem existem</a> no modelo de negócios.</p><h3>Hierarquias Complexas</h3><p>Eu defino Hierarquias Complexas todos os modelos de Classes que utilizam Herança e que contenham erros conceituais ou reais. E eu sempre encontro esses tipos de erros. Sempre. A não ser que seu modelo seja muito pequeno, ele também conterá esses erros. O motivo é simples. É quase impossível definir uma Hierarquia de Classes perfeita porque o mundo real, o qual modelamos utilizando Classes, não é estruturado.</p><p>Isso mesmo, a natureza não é estruturada. Não disse que não ela não é perfeita. Estou dizendo que ela não é estruturada como Classes perfeitamente agrupadas numa Hierarquia bonita e elegante. Na minha opinião, a natureza é um caos.</p><p>Na <a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-3/#exemplo-1">Parte #3</a> dessa série eu apresentei um modelo de Classes do Mundo Animal.</p><p>Aqui está o Diagrama:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DZ-NZTVL744XMHEM.png" /></figure><p>A princípio, parece simples e correto. Todos os animais no modelo são Animais, obviamente, e todos eles Caminham. Bem, com exceção do Tubarão, pois ele não tem pernas mas… vamos ignorar isso. Imagine um raise Exception.Create no método Caminhar do Tubarão e vamos em frente.</p><p>E se quisermos adicionar mais animais nessa Hierarquia? Talvez um Tigre.</p><p>Você pode imaginar que um Tigre herde de Gato — ou seria o contrário? — e tudo irá continuar funcionando. Bonito e elegante.</p><p>O mesmo para um Leão, Lobo, Urso… e então precisamos implementar um Ornitorrinco.</p><p>O que é um Ornitorrinco?</p><blockquote><em>Com bico de ave, semelhante a pato, é um mamífero semiaquático natural da Austrália e Tasmânia. É o único representante vivo da família Ornithorhynchidae, e a única espécie do gênero Ornithorhynchus. Juntamente com as equidnas, formam o grupo dos monotremados, os únicos mamíferos ovíparos existentes. A espécie é monotípica, ou seja, não tem subespécies ou variedades reconhecidas.</em></blockquote><blockquote><em>— Wikipedia</em></blockquote><p>É um mamífero, ovíparo, tem bico e nadadeiras e é uma mono espécie… se a natureza fosse estruturada, esse seria um dos seus <em>bugs</em>?</p><p>Pense agora no peixe-voador…</p><p>Brincadeira a parte, eu acredito que não, que não há nada de errado com o Ornitorrinco ou qualquer outro animal.</p><p>Nosso Modelo de Classes, baseado em Herança, é que está errado.</p><p>Imagine o modelo acima bem maior, com mais métodos e Subclasses. Para tentar colocar o Ornitorrinco na Hierarquia você teria que fazer uma refatoração possivelmente grande. Criar novas classes abastratas, mover métodos para Classes acima, outros para Classes abaixo, “desabilitar” alguns métodos utilizando raise e seguir a vida.</p><p>A Hierarquia iria ficar <strong>extremamente complexa</strong>. Iriam existir Classes que só existiram para compartilhar código, e não porque o <strong>modelo de negócios</strong> exige que existam.</p><p>Sempre foi assim nos sistema que utilizam Herança, certo? Aquele <em>Form</em> que tem um botão que não é necessário na Subclasse, basta setar um Visible = False e tudo certo; um botão que faz algo a mais do que é preciso na nova Subclasse, basta “refatorar” o código dividindo em 2 métodos com nomes insípedos e fazer a chamada deles, sobrescrevendo o método original para chamar apenas uma parte do código; sobrescrever métodos da super Classe para “não fazer nada”; copiar código de outra hierarquia de Classes… uma verdadeira bagunça.</p><p>Eu conheço esses problemas. Eu passei por muitos deles. E, acredite, em grande parte o motivo dos problemas sempre foram as Hierarquias Complexas que criamos sem pensar, quando estamos tentando “reaproveitar” código utilizando Herança.</p><p>Na natureza, eu acredito, não há “reaproveitamento de código”, só composição.</p><p>Átomos, elementos químicos. Alguns organismos tem mais disso, outros mais daquilo. Um animal tem 0,0003% desse elemento, mais 0,0006% de outro. A composição desses Objetos determinam o comportamento e a evolução de cada indivíduo.</p><p>DNA.</p><p>Lembre-se que <a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-3/#solucao">a árvore</a> não existe. Tetrápodes, Bípedes, Mamíferos, Anfíbios, Aves… nada disso existe. São abstrações que nós criamos para organizar as coisas, mas elas <strong>não existem no mundo real</strong>.</p><p>Qualquer Hierarquia de Classes que tente implementar o mundo, terá falhas.</p><p>Parece que os biólogos conseguem separar os indivíduos em “hierarquias perfeitas”. Eles observam os indivíduos na natureza e classificam. Se descobrem um animal que não se encaixa em nenhuma hierarquia não há problema, basta criar uma nova. Nenhum animal já classificado será afetado. Não há um “fio” que liga os animais às hierarquias. O indivíduo determina a hierarquia, ou seja, de baixo pra cima. As hierarquias são apenas nomes e classificações. Ontologia.</p><blockquote><em>A ontologia não define o comportamento das amostras individuais.</em></blockquote><p>Nós, desenvolvedores de software, fazemos o inverso. Vamos codificando nossas hierarquias e tentando definir o comportamento dos objetos de cima pra baixo! É como se tentássemos prever o futuro da evolução de nossas Classes separando-as em hierarquias pré-definidas. É praticamente impossível dar certo.</p><h3>Solução</h3><p>A solução é a Composição de Objetos em conjunto com Interfaces. Já falei isso. Falei e repeti muitas vezes. Mas para quem ainda não entendeu, vou revelar mais uma dica através de uma pergunta:</p><p><strong>Se seu sistema trabalha com Tigres, quantas Classes Tigre você teria?</strong></p><p>A grande maioria, acredito, responderia <strong>apenas uma classe</strong> TTigre.</p><p>Concorda?</p><p>A pergunta é capciosa.</p><p>Esse é um dos problemas ao tentarmos modelar sistemas Orientados a Objetos. O desenvolvedor acha que apenas uma Classe deve representar o conceito quando, na verdade, podemos ter <strong>diferentes Classes para representar o mesmo conceito em diferentes contextos</strong>.</p><p>As pessoas me perguntaram quais eram as soluções para os problemas apontados nessa série. Eu lhes disse, Composição de Objetos.</p><p>Mas elas esperavam ler a solução definitiva: Quais classes criar; quais interfaces; usar ou não herança; em quais Classes por tais métodos.</p><p>Não há uma única resposta, porque tudo irá depender do seu modelo de negócios. Uma vez que você saiba o modelo de negócios, deverá haver a definição de contextos — Bounded Context no DDD — e assim você terá “N” <a href="http://objectpascalprogramming.com/posts/objetos-representam-entidades/#o-que-e-uma-entidade">variações de um único conceito</a>.</p><p>Lembra do TTigre? Se nesse sistema hipotético você precisa analisar na tela a pata de um tigre, não haveria necessidade de instânciar um objeto da Classe TTigre que contém tudo de um tigre (olhos, tipo, peso, tamanho, cor, que corre, nada, caça, etc). Não estou dizendo isso pensando em performance ou alocação de memória, não! Estou dizendo isso porque essa Classe seria enorme e complexa. Iria implementar muitas interfaces para poder Correr, Nadar, Pular… num sistema precisamos abstrair o que não é necessário. Esse é um dos motivos de não precisarmos de Hierarquias Complexas. Se você precisa examinar uma pata, então:</p><pre>type<br>  IPaw = interface<br>    <em>// function...</em><br>  end;<br>  <br>  TTigerPaw = class(TInterfacedObject, IPaw)<br>  public<br>    <em>// function...</em><br>  end;</pre><p>Assim como você poderá utilizar os Objetos da Classe TTigerPaw para compor outras abstrações de Tigre em outros contextos.</p><p>Sim, você terá muito mais definições de Classes. Mas isso já é previsto na Composição de Objetos. Fazer o certo dá mais trabalho, mas só no início.</p><h3>Conclusão Final</h3><p>Chegamos ao final dessa série. Falei sobre como a Herança Viola o Encapsulamento, pode Duplicar o Código, promove Forte Acoplamento e Hierarquias Complexas.</p><p>Espero ter lhe ajudado a entender mais sobre Herança de Classes e os males que ela pode trazer ao código.</p><p>O título dessa série é “Herança <strong>pode</strong> ser o Mal da Orientação a Objetos”. Eu não falei que ela <strong>é</strong>, disse que pode ser. Eu lhe mostrei os problemas que vem com a Herança de Classes. Tenha conhecimento deles e evite-os.</p><p>Herança de Classe pode ser benéfica em alguns (poucos) contextos. Mas ao usá-la uma vez, a tentação é grande em continuar utilizando. Não faça isso.</p><p>Modele suas Classes utilizando Composição de Objetos que implementam Interfaces. Esse é o segredo.</p><p>Até logo.</p><p><em>Originalmente publicado em </em><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-final/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0c6b4b2b9f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Herança pode ser o Mal da Orientação a Objetos — Parte 4]]></title>
            <link>https://medium.com/@mdbs99/heran%C3%A7a-pode-ser-o-mal-da-orienta%C3%A7%C3%A3o-a-objetos-parte-4-d9577647e6f9?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9577647e6f9</guid>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[object-pascal]]></category>
            <category><![CDATA[delphi]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[oop]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Fri, 01 Jul 2016 13:46:14 GMT</pubDate>
            <atom:updated>2016-07-02T16:02:13.765Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/986/0*xENFEFqtXUBvyo1R.jpg" /></figure><p>No artigo anterior falei sobre Duplicação de Código. Nesse artigo irei falar sobre o <strong>Forte Acoplamento</strong> que ocorre ao utilizarmos a Herança de Classe.</p><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-3/">Clique aqui</a> para ler a <strong>Parte #3</strong> dessa série, caso ainda não tenha lido.</p><h3>Introdução</h3><blockquote><em>Se um gato possui raça e patas, e um cachorro possui raça, patas e tipoDoPelo, logo Cachorro extends Gato?</em></blockquote><p>O texto acima é emprestado <a href="http://blog.caelum.com.br/como-nao-aprender-orientacao-a-objetos-heranca/">desse artigo</a> que fala sobre Herança e Hierarquia de Classes. O artigo fala sobre o erro de <em>design</em> dos projetistas da linguagem Java quando codificaram as Classes Stack e Properties. Não precisa conhecer Java para entender o artigo.</p><p>No mesmo artigo ele mostra o erro <strong>grotesco</strong> no <em>design</em> da Classe HttpServlet.</p><p>Se você já utilizou Java e precisou extender essa Classe, deve ter reparado no mesmo problema citado no artigo.</p><p>Na época da faculdade eu reparei nesse erro de <em>design</em> mas, <strong>ignorei</strong>. Achei que eu estava errado, que não tinha entendido a “maneira correta de programar utilizando Orientação a Objetos com Java”. Eu não sabia muita coisa mesmo. Talvez ainda não saiba… sempre que leio textos de outrem fico indignado o quanto ainda preciso aprender. Pois é.</p><p>O fato é que o pensamento comum da maioria das pessoas é: Será que uma grande empresa, projetista do Java por exemplo, poderia estar errada?</p><p>Sim as empresas erram, muito.</p><p>Sim, elas também ganham muito dinheiro. Mas não é porque seus <em>softwares</em> são perfeitos, mas sim porque elas se adaptam rapidamente e dão aos seus clientes o que eles querem — ou o que está na moda; ou algo similar ao concorrente; ou talvez algo “legal de se ter”.</p><p>Por isso muitas empresas não se importam em descontinuar aplicativos e <em>frameworks</em> se eles não dão lucro ou não estão mais em conformidade com a visão de longo prazo delas — vide Microsoft — o que é perfeitamente normal. Elas precisam gerar lucro, certo?</p><p>Então não pense que as empresas milionárias como a Microsoft, Sun/Oracle, Embarcadero e muitas outras, estão sempre certas “só” porque elas são milionárias. Bem, elas estão corretíssimas sobre gerar lucro, mas nem sempre estão corretas sobre <strong>arquitetura e desenvolvimento</strong> de <em>softwares</em>.</p><h3>Forte Acoplamento</h3><p>O termo <a href="https://en.wikipedia.org/wiki/Coupling_(computer_programming)">Acoplamento</a> é uma medida de quão duas rotinas, módulos ou Classes estão ligados <strong>intimamente</strong>.</p><blockquote><em>Em engenharia de software, acoplamento é a maneira e grau de interdependência entre módulos de software. Coupling — Wikipedia</em></blockquote><p>Existem várias formas de acoplamento.</p><p>O Forte Acoplamento entre Classes se dá quando uma Classe “conhece” uma outra diretamente. Por exemplo. Quando você inicializa um atributo de uma Classe utilizando uma Classe concreta, você está acoplando as Classes.</p><pre>constructor TCustomer.Create(const Name: string);<br>begin<br>  inherited Create;<br>  FName := Name;<br>  FAddress := TAddress.Create;<br>end;</pre><p>No exemplo acima existe um acoplamento entre TCustomer e TAddress. Conceitualmente isso é ruim. O mais correto seria utilizar <strong>injeção de dependência</strong> passando a instância de TAddress através de um argumento do tipo Interface no construtor de TCustomer.</p><pre>constructor TCustomer.Create(const Name: string; <br>  Address: IAddress);<br>begin<br>  inherited Create;<br>  FName := Name;<br>  FAddress := Address;<br>end;</pre><p>Devemos evitar o acoplamento. O motivo é simples. Toda vez que você alterar uma Classe que está acoplada a outra, haverá grandes chances de você ter que alterar ambas.</p><p>Se utilizar argumentos do tipo <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Interface</a> e injeção de dependência, o acoplamento será apenas de Interfaces.</p><p>O exemplo acima não é sobre Herança, mas sobre <strong>Composição de Objetos</strong>.</p><p>Apesar de ser ruim o acoplamento sem utilizar injeção de dependência, é possível refatorar essas Classes (se necessário) sem termos que alterar todas as Classes envolvidas. Poderíamos começar a codificação de TCustomer sem injetar TAddress e, depois, resolver alterar o código para tornar TCustomer mais desacoplada.</p><p>No entanto, se utilizássemos <strong>Herança de Classe</strong>, a mesma refatoração poderia ser <strong>muito mais difícil</strong>. Por exemplo. Se TCustomer fosse uma Subclasse de TPerson e essa Classe inicializasse FAddress em seu construtor, TCustomer não poderia — ou não deveria — alterar a instância de FAddress, reinicializando-a com um outro tipo de Classe.</p><pre><em>{ TPerson }</em><br><br>constructor TPerson.Create(const Name: string);<br>begin<br>  inherited Create;<br>  FName := Name;<br>  FAddress := TAddress.Create;<br>end;<br><br><em>{ TCustomer }</em><br><br>constructor TCustomer.Create(const Name: string);<br>begin<br>  inherited Create(Name);<br>  FAddress := TAnotherAddress.Create; <em>//&lt;&lt;&lt;</em><br>end;</pre><p>Nesse exemplo simples, existem alguns problemas.</p><p>Primeiro, para que TCustomer consiga alterar FAddress, esta deve ter a visibilidade de protected, o que é uma <a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-2/">Violação de Encapsulamento</a>, pois TCustomer teria conhecimento interno sobre o estado de TPerson.</p><p>Segundo, se TCustomer tem acesso de alteração dos atributos herdados de TPerson, esta mudança poderia causar inúmeros problemas pois o comportamento de TPerson poderia ser alterado ou invalidado para todos as outras Subclasse de TPerson.</p><p>E terceiro, se FAddress não fosse protected nenhuma opção estaria disponível.</p><h3>A Classe TDataSet</h3><p>Erros de <em>design</em> de Classes não existem só na linguagem Java. No Delphi também temos erros. Um deles, na minha opinião, é a Classe TDataSet.</p><p>Por simplicidade, talvez, alguém pensou em fazer uma Classe para manipulação de dados. É o famoso <em>data-ware</em>. Componentes mostram dados em <em>widgets</em> (edits, grids, etc) obtendo esses dados de instâncias de Subclasses de TDataSet.</p><p>Esse é um abuso clássico da Herança: Utilização da Herança para reaproveitar código.</p><p>Bem, se a Herança fosse mesmo uma boa escolha, eu estaria utilizando Herança nas minhas Classes. Teria minha própria Hierarquia de Classes e Subclasses, certo?</p><p>Então eu lhes pergunto: Onde TDataSet faria sentido na minha Hierarquia de Classes? Provavelmente nenhum sentido. No entanto eu sou <strong>obrigado</strong> a herdar de TDataSet se eu quiser exibir dados num TDBGrid. Esse <em>design</em> é muito errado.</p><p>E qual seria o <em>design</em> correto?</p><p>Você já sabe.</p><p>Todos os lugares que esperam uma instância de TDataSet deveriam esperar uma Interface IDataSet. Tão simples quanto utilizar Herança, porém mais eficiente e desacoplado.</p><h3>Conclusão</h3><p>A utilização de Herança é a pior forma de acoplamento porque é mais difícil de corrigir e refatorar.</p><p>Utilizar Herança é como usar concreto, após secar você não consegue mover mais nada.</p><h3>No próximo artigo…</h3><p>No próximo artigo irei falar sobre <strong>Hierarquias Complexas</strong> entre Classes que utilizam Herança.</p><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-final/">Clique aqui</a> para ler a <strong>Parte Final</strong> dessa série.</p><p>Caso você tenha alguma dúvida ou quiser compartilhar seus pensamentos sobre essa série, utilize a área abaixo para comentários.</p><p>Até logo.</p><p><em>Originalmente publicado em </em><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-4/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9577647e6f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Herança pode ser o Mal da Orientação a Objetos — Parte 3]]></title>
            <link>https://medium.com/@mdbs99/heran%C3%A7a-pode-ser-o-mal-da-orienta%C3%A7%C3%A3o-a-objetos-parte-3-d4bd34b46842?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4bd34b46842</guid>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[object-pascal]]></category>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[delphi]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Sat, 18 Jun 2016 12:27:11 GMT</pubDate>
            <atom:updated>2016-06-18T12:27:11.621Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*eF5-I7kFsMtqtkZ7.jpg" /></figure><p>No artigo anterior falei sobre Violação de Encapsulamento. Nesse artigo irei falar sobre a <strong>Duplicação de Código</strong> ao utilizarmos a Herança de Classe.</p><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-2/">Clique aqui</a> para ler a <strong>Parte #2</strong> dessa série, caso ainda não tenha lido.</p><h3>Introdução</h3><p>Duplicação de Código utilizando Herança. Essa afirmação pode parecer <strong>heresia</strong> porque a maioria dos programadores utilizam Herança de Classe justamente para <strong>não</strong> duplicar o código.</p><p>Em uma hierarquia de classes onde B e C herdam de A, basta adicionar a nova funcionalidade em A para termos disponível em B e C. Simples, rápido e sem duplicar código.</p><p>Mas será esse o melhor <em>design</em> para <strong>reaproveitar</strong> e não duplicar código?</p><blockquote><em>A Herança de Classe é simples de usar e entender, mas no longo prazo é provado que essa não é a melhor escolha ao projetar seu diagrama de Classes. Ao invés de Herança a melhor escolha é a </em><a href="https://en.wikipedia.org/wiki/Composition_over_inheritance"><em>Composição de Objetos</em></a><em>.</em></blockquote><p>Quando estamos começando um novo projeto — ou um novo módulo — sim, essa <strong>parece</strong> ser ser a “melhor maneira” para reaproveitar código.</p><p>Parece.</p><p>Com certeza a Herança é <strong>simples</strong> e <strong>intuitiva</strong> no entanto não é o melhor <em>design</em> no médio e longo prazo.</p><p>Herança de Classe leva a um código altamente acoplado e sem flexibilidade.</p><h3>Duplicando o código</h3><p>Então, como é possível duplicar o código utilizando Herança?</p><p>Utilizando <strong>Hierarquias de Classes</strong>.</p><p>É contra intuitivo pensar nisso, mas é verdade. Pense por um minuto. Se você tem um comportamento/funcionalidade espalhado entre Classes e Subclasses dentro de uma Hierarquia, como <strong>reutilizar</strong> esse código em outras Classes ou Hierarquias diferentes? Difícil.</p><p>Não estou dizendo que é impossível. Estou dizendo que <strong>dificulta</strong> muito a reutilização devido o comportamento não ter sido codificado de maneira <strong>coesa</strong>, utilizando <strong>Classes pequenas</strong> com <a href="http://objectpascalprogramming.com/posts/classes-devem-implementar-apenas-uma-responsabilidade/">apenas uma responsabilidade</a>.</p><p>Quando utilizamos Herança somos seduzidos pelo <strong>fácil reaproveitamento</strong> do código e por isso vamos agregando mais e mais funcionalidades nas Classes e Subclasses, tornando-as “inchadas” e dificultando o reaproveitamento entre módulos ou Projetos distintos.</p><p>Na maioria das vezes exigirá uma refatoração massiva no código para haver reutilização, devido as Classes e Subclasses estarem muito acopladas umas as outras.</p><p>Esse é o motivo da <strong>Duplicação de Código</strong>. É muito mais fácil e confortável — para a maioria dos programadores com prazos curtos e chefes estressados — duplicar o código do que refatorar, talvez, toda a Hierarquia.</p><h3>Exemplo</h3><p>Vejamos agora um exemplo utilizando Diagramas de Classes.</p><p>Antes eu gostaria de lembrá-lo que é fácil olhar um exemplo simples e pensar em inúmeras maneiras de fazê-lo melhor. Mas pense que esses são apenas exemplos para lhe mostrar o conceito e não a melhor maneira de implementar uma solução.</p><h3>O Mundo Animal</h3><p>Vou começar com o bom e velho “Exemplo de Animais”. O exemplo é antigo, sim, porém você ainda tem dúvidas sobre utilizar ou não herança — senão não estaria lendo esse artigo — então acho que o exemplo continua sendo válido.</p><p>Precisamos implementar um sistema que lida com Animais e resolvemos utilizar Herança de Classes para implementar uma Hierarquia e “reutilizar o código”.</p><p>Primeiramente o sistema só irá trabalhar com Cachorros e Gatos então temos o primeiro modelo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/0*OYcOfR8lWOUzse0a.png" /></figure><p>No diagrama acima temos 3 Classes simples: Animal, Cachorro e Gato.</p><p>Apenas a Classe Animal tem um método Caminhar() que é herdado para as Classes Cachorro e Gato. Queremos reaproveitar o código então basta implementar na Classe mais acima da Hierarquia, ou seja, Animal.</p><p>Então vamos imaginar como seria a implementação do método Caminhar().</p><pre>function TAnimal.Caminhar: TAnimal;<br>begin<br>  Result := Self;<br>  MovePata1;<br>  MovePata2;<br>  MovePata3;<br>  MovePata4;<br>end;</pre><p>Como estamos trabalhando, a princípio, com tetrápodes ou quadrúpedes, precisamos mover as 4 patas para caminhar. Tudo funciona perfeitamente.</p><p>Então precisamos acrescentar mais alguns animais: Pato, Tubarão, Sapo, Morcego e Crocodilo.</p><p>Como somos espertos, vamos acrescentar mais abstrações para deixar o modelo mais “legal” e “sofisticado”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gJg9pB0ZpkpH7o6O.png" /></figure><p>Um Pato também caminha, no entanto ele caminha utilizando 2 membros. O Sapo e Crocodilo caminham com 4 patas, assim como o Cachorro e Gato. O Morcego tem pernas, mas ele realmente caminha? Não sei. O Tubarão… complicou.</p><p>Veja que pelo simples fato de termos acrescentado outros animais, <strong>toda a hierarquia deverá ser verificada</strong> afim de saber se os métodos de Classes ancestrais continuam fazendo sentido para a nova hierarquia.</p><p>O que fazer? Há inúmeras possibilidades. Algumas mais certas, outras mais erradas. Mas o que é que a <strong>maioria</strong> dos programadores fazem — inclusive em <a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-2/#exemplo-3">grandes empresas</a> — quando a hierarquia não reflete o mundo real?</p><p>Eles sobrescrevem métodos, <strong>ignorando-os</strong> (métodos em branco) ou <strong>lançando uma exceção</strong> (métodos que existem, mas não devem ser utilizados… WTF!).</p><p>Nesse ponto emerge a Duplicação de Código.</p><p>Como assim?</p><p>Dependendo da quantidade de Classes numa hierarquia, duplicar a implementação será o método escolhido. No caso do nosso exemplo o método Caminhar() seria modificado para utilizar apenas 2 patas em algumas Classes. Em outras levantaríamos uma exceção naqueles Animais que não deveriam caminhar, como no caso da Classe Tubarão.</p><p>Mas isso é uma <strong>solução alternativa</strong> que está longe de ser a ideal.</p><h3>Solução</h3><p>A Hierarquia está errada? Qual seria a implementação “certa”? Como reaproveitar o código sem usar Herança?</p><p>Quando os cientistas separam os animais em “Classes”, eles fizeram-na baseado no que eles são (identidade) e não no que eles fazem (comportamento).</p><p>Um pato nada, assim como um crocodilo. Mas o ato de nadar <strong>não pertence</strong> ao pato nem ao crocodilo, pois nadar é um <strong>comportamento</strong> “implementado” em vários outros Animais (Classes).</p><p>Vou lhe contar como resolver o problema da implementação da Hierarquia Animal.</p><p><strong>Atenção</strong>, aqui está:</p><p>Um Animal não caminha. Quem caminha é um Cachorro, Gato ou Pato. Animal é uma abstração, uma classificação, assim como Mamífero ou Anfíbio. Animal não existe.</p><p>Tetrápodes, Bípedes, Mamíferos, Anfíbios, Aves, Peixes, Pássaros… <strong>eles não existem</strong>!</p><p>Que?!</p><p>É isso aí.</p><p>Não entendeu? Aqui vai outro exemplo.</p><p>Você já viu uma Árvore? Tenho certeza que não! Você viu, talvez, uma goiabeira, bananeira, macieira… Árvore é uma abstração, uma classificação. Árvore não existe.</p><p>Se Mamíferos, Anfíbios, Aves, Peixes…e Árvores não existem, o que são?</p><p>São apenas <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Interfaces</a> que definem uma classificação para algum comportamento.</p><p>Então não há — ou não deveria haver — Hierarquia de Classes, apenas <strong>Hierarquias de Interfaces</strong>!</p><p>Cientistas não tem problemas em classificar novas espécieis porque a inclusão na hierarquia existente não “quebra” nenhuma “funcionalidade” nas “Classes” abaixo desta. São apenas Interfaces.</p><p>Então, se não há Hierarquia de Classes, como reaproveitar código sem duplicar?</p><p>Resposta: <strong>Composição de Objetos</strong>.</p><p>Objetos tem comportamento, Interfaces não. Um cachorro é um Objeto; um pato é um Objeto; o ato de caminhar é um comportamento de “algum objeto” que os pássaros sabem utilizar… ou será que <strong>Alguém</strong> “Duplicou o Código” em cada DNA porque era mais fácil de implementar? :)</p><h3>No próximo artigo…</h3><p>No próximo artigo irei falar sobre <strong>Forte Acoplamento</strong> entre Classes que utilizam Herança.</p><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-4/">Clique aqui</a> para ler a <strong>Parte #4</strong> dessa série.</p><p>Caso você tenha alguma dúvida ou quiser compartilhar seus pensamentos sobre essa série, utilize a área abaixo para comentários.</p><p>Até logo.</p><p><em>Originalmente publicado em </em><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-3/"><em>objectpascalprogramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4bd34b46842" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Herança pode ser o Mal da Orientação a Objetos — Parte 2]]></title>
            <link>https://medium.com/@mdbs99/heran%C3%A7a-pode-ser-o-mal-da-orienta%C3%A7%C3%A3o-a-objetos-parte-2-98c9cbd87624?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/98c9cbd87624</guid>
            <category><![CDATA[brazil]]></category>
            <category><![CDATA[object-pascal]]></category>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[delphi]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Sat, 11 Jun 2016 13:46:16 GMT</pubDate>
            <atom:updated>2016-06-11T13:46:16.737Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*nqcDf6TbiIixYOe9.jpg" /></figure><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-1/">Clique aqui</a> para ler a <strong>Parte #1</strong> dessa série, caso ainda não tenha lido.</p><p>No artigo anterior citei alguns males ao utilizarmos Herança de Classe. Nesse artigo irei falar sobre um deles, a <strong>Violação de Encapsulamento</strong> ao utilizarmos Subclasses.</p><h3>Introdução</h3><p>Há muitos artigos na internet que falam sobre esse assunto, mas não encontrei nenhum que tenha apresentado esse conceito, de forma satisfatória, para programadores <em>Object Pascal</em> e, aqui estamos.</p><p>Então, como um dos pilares da Orientação a Objetos, a Herança, pode se <strong>contrapor</strong> a outro princípio, o <strong>Encapsulamento</strong>?</p><blockquote><em>…a herança de classe permite definir a implementação de uma classe em termos da implemetação de outra. A reutilização por meio de sublcasses é frequentemente chamada de reutilização de caixa branca (ou aberta). O termo “caixa branca” se refere à visibilidade: com herança, os interiores das classes ancestrais são frequentemente visíveis para subclasses. Padrões de Projetos, 2002 — p.34 — Erich Gamma e outros — ISBN 85–7307–610–0</em></blockquote><p>O texto é claro.</p><p>O autor escreveu que <strong>“…os interiores das classes ancestrais são frequentemente visíveis para subclasses”</strong>. Ele não escreveu, especificamente, que a Herança Viola o Encapsulamento mas você percebeu que é a mesma coisa?</p><p>O interior de uma Classe não pode ser visível, mesmo para Subclasses, porque isso significaria <strong>violação de encapsulamento</strong>. Ponto.</p><blockquote><em>Porque a herança expõe para uma subclasse os detalhes da implementação dos seus ancestrais, frequentemente é dito que “a herança viola a encapsulação”[Sny86] Padrões de Projetos, 2002 — p.34</em></blockquote><p>Quando li isso a primeira vez, pouco tempo depois que comecei a codificar software “Orientado a Objetos” — eu achava que estava utilizando Orientação a Objetos — tive o sentimento de <strong>negação</strong> que você pode estar tendo agora:</p><p>— “Ora, isso não faz o menor sentido!”</p><p>Mas faz todo o sentido. Vou repetir: A Herança Viola o Encapsulamento.</p><p>Isso é um <strong>fato lógico</strong>. Pode não parecer lógico se é a primeira vez que você lê essa afirmação, mas você entenderá.</p><h3>Encapsulamento</h3><p>Precisamos definir o que é Encapsulamento que, de acordo com o dicionário, significa: <strong>colocar ou encerrar em cápsula; capsular</strong>.</p><p>Uma cápsula não pode — ou não deveria — ser quebrada. O mundo externo ao Objeto não pode saber o que há em seu interior a menos que o Objeto queira lhes dizer “com suas próprias palavras”, ou seja, através de métodos que retornam informações mas não necessariamente seu <a href="http://objectpascalprogramming.com/posts/o-que-e-orientacao-a-objetos/#objeto-nao-e-um-balde-de-funcoes-e-dados">Estado</a>.</p><p>O mundo externo só deve conhecer os métodos públicos de um Objeto. Seus métodos públicos representam sua <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Interface</a> para fazer o que ele deve fazer. Qualquer método ou atributo interno ao Objeto é de propriedade dele e de mais ninguém.</p><p>Um Objeto pode ter um único método em sua Interface porém pode haver 10 outros métodos privados apenas para resolver um único problema. Mas o mundo externo não sabe e não deve saber como o Objeto trabalha internamente.</p><p>Um subtipo de Classe viola esse conceito.</p><h3>Herança de Classe</h3><p>O motivo de termos Subclasses é <strong>acrescentar</strong> mais funcionalidade às Classes ancestrais, criando um novo tipo. Ao acrescentar funcionalidades a nova Subclasse deverá, inevitavelmente, interagir com o Estado e Métodos protegidos da Classe ancestral. Em outras palavras, a Subclasse deverá conhecer como a Classe ancestral trabalha (internamente) para poder adicionar funcionalidade, o que é uma clara <strong>Violação de Encapsulamento</strong>.</p><blockquote><em>A implementação de uma Subclasse, dessa forma, torna-se tão amarrada à implementação da sua classe-mãe que qualquer mudança na implementação desta forçará uma mudança naquela. Padrões de Projetos, 2002 — p.34</em></blockquote><p>A Herança de Classe é simples de usar e entender, mas no longo prazo é provado que essa não é a melhor escolha ao projetar seu diagrama de Classes. Ao invés de Herança a melhor escolha é a <a href="https://en.wikipedia.org/wiki/Composition_over_inheritance">Composição de Objetos</a>. Esse é um dos princípios proposto no livro Padrões de Projetos:</p><p><em>Favoreça a composição de objetos em relação à herança de classe</em>.</p><p>Foi o que fizeram os engenheiros do Google ao projetar a <a href="https://golang.org/">Go language</a>. A linguagem <a href="https://talks.golang.org/2012/splash.article#TOC_15">não tem nenhuma forma</a> de Herança de Classes, ou seja, Herança baseada em subtipos. Não há hierarquia de tipos!</p><h3>Me mostre o Código</h3><p>A teoria foi explicada. Agora vou lhe mostrar alguns exemplos de código.</p><p>Não posso colocar exemplos completos e reais senão o artigo iria virar um “repositório de código” e não um artigo. Então veja os exemplos e imagine como seria no código real.</p><h3>Exemplo 1 — Stack Overflow</h3><p>É um exemplo simples que poderia ser evitado pelo programador que fez a Classe A, a classe ancestral, no entanto veja que para descobrir o problema o programador da Classe B, a Subclasse, deve ver como a Classe A foi implementada, Violando o Encapsulamento, pois ele deverá fazer ajustes em função da implementão interna da Classe A:</p><pre>type<br>  TClasseA = class<br>  protected<br>    procedure Exec; virtual;<br>  public<br>    procedure Proc;<br>  end;<br><br>  TClasseB = class(TClasseA)<br>  protected<br>    procedure Exec; override;<br>  end;<br><br><em>{ TClasseA }</em><br><br>procedure TClasseA.Exec;<br>begin<br>  ShowMessage(&#39;Exec&#39;)<br>end;<br><br>procedure TClasseA.Proc;<br>begin<br>  Exec;<br>end;<br><br><em>{ TClasseB }</em><br><br>procedure TClasseB.Exec;<br>begin<br>  Proc;<br>end;<br><br><em>{ TForm1 }</em><br><br>procedure TForm1.Button1Click(Sender: TObject);<br>begin<br>  with TClasseA.Create do<br>  try<br>    Proc;<br>  finally<br>    Free;<br>  end;<br><br>  with TClasseB.Create do<br>  try<br>    Proc;<br>  finally<br>    Free;<br>  end;<br>end;</pre><p>A Classe B sobrescreve um método da Classe A. Simples. Fazemos isso todo tempo. Então, qual é o problema desse código?</p><p>Se você copiar/colar o código na sua IDE e executar, verá uma mensagem de erro na segunda execução de Proc. Essa mensagem pode variar de IDE mas basicamente é um <em>Stack Overflow</em>. Ao sobrescrever Exec na Classe B, o programador chamou Proc internamente. O problema é que na Classe A, Proc já está chamando Exec e, dessa forma, o programa entra em um <em>loop</em> infinito.</p><h3>Exemplo 2 — Utilizar inherited ou não?</h3><p>Quando sobrescrevemos um método há a possibilidade de chamar o código do mesmo método da Classe ancestral. Para isso utilizamos a palavra reservada inherited.</p><p>Mas como saber se devo ou não chamar o código da Classe ancestral?</p><p>Somente olhando a implementação privada da Classe para termos certeza se <strong>devemos ou não</strong> chamar o código. Novamente, temos uma Violação de Encapsulamento.</p><pre>type<br>  TClasseA = class<br>  protected<br>    FCount: Integer;<br>  public<br>    procedure Exec; virtual;<br>  end;<br><br>  TClasseB = class(TClasseA)<br>  public<br>    procedure Exec; override;<br>  end;<br><br><em>{ TClasseA }</em><br><br>procedure TClasseA.Exec;<br>begin<br>  FCount := FCount + 1;<br>  ShowMessage(&#39;Count=&#39; + IntToStr(FCount)); <em>//=1</em><br>  ShowMessage(&#39;Exec A&#39;);<br>end;<br><br><em>{ TClasseB }</em><br><br>procedure TClasseB.Exec;<br>begin<br>  inherited;<br>  FCount := FCount + 1;<br>  ShowMessage(&#39;Count=&#39; + IntToStr(FCount)); <em>//=2</em><br>  ShowMessage(&#39;Exec B&#39;);<br>end;<br><br><em>{ TForm1 }</em><br><br>procedure TForm1.Button1Click(Sender: TObject);<br>begin<br>  with TClasseB.Create do<br>  try<br>    Exec;<br>  finally<br>    Free;<br>  end;<br>end;</pre><p>Quando executado teremos as mensagens:</p><ol><li>“Count=1”</li><li>“Exec A”</li><li>“Count=2”</li><li>“Exec B”</li></ol><p>Nesse exemplo o programador utilizar inherited porque ele sabe — olhando para a implementação de TClasseA.Exec — que a execução da Classe ancestral iria incrementar o atributo FCount antes que ele fosse incrementado novamente no método sobrescrito.</p><p>É um exemplo idiota, mas serve para o que eu quero lhe mostrar.</p><p>Como eu disse, tente imaginar um código em produção, pensando quantas vezes você já teve que ver o código da Classe ancestral (ou uma hierarquia de classes inteira) para saber se podia ou não chamar um método; se devia ou não chamar o código ancestral do método; se um determinado atributo já havia sido inicializado, etc.</p><p>Antigamente, nos compiladores mais antigos, era possível fazer uma chamada a um método abstrato — sei que o compilador FreePascal não permite, nem compila — mas não sei se o compilador atual do Delphi permite. Bem, em compiladores antigos esse é mais um problema: “Será que posso utilizar inherited nesse método? Como saber se é abstrato?”</p><p>Se não me engano, acho que o Java permite a chamada a métodos abstratos — me corrijam se eu estiver errado.</p><h3>Exemplo 3 — Herança pode ser o Mal em qualquer lugar</h3><p>O próximo exemplo não é sobre <em>Object Pascal</em>, mas sim Java. Muitas pessoas pensam que algo está correto só porque foi feito por uma grande empresa. Não. Pode ser uma grande empresa lucrativa, porém seus programadores não são robôs, eles falham.</p><blockquote><em>Quando então usar herança? Essa é uma questão difícil. Na minha visão particular, a resposta seria um enfático “quase nunca”. Como não aprender orientação a objetos: Herança — Paulo Silveira</em></blockquote><p><a href="http://blog.caelum.com.br/como-nao-aprender-orientacao-a-objetos-heranca/">Clique aqui</a> para ler o artigo na íntegra e ver como os arquitetos do Java erraram incrivelmente no <em>design</em> da arquitetura de <em>Servlets</em>.</p><p>A solução proposta pelo autor do artigo é a mesma que proponho em quase todos os posts aqui no blog: <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Utilize Interfaces</a>.</p><h3>No próximo artigo…</h3><p>Espero que você tenha entendido. Herança viola o Encapsulamento. Não é apenas um conceito, mas um fato.</p><p>No próximo artigo irei falar mais sobre <strong>Duplicação de Código</strong> ao utilizarmos a Herança de Classe.</p><p><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-3/">Clique aqui</a> para ler a <strong>Parte #3</strong> dessa série.</p><p>Caso você tenha alguma dúvida ou quiser compartilhar seus pensamentos sobre essa série, utilize a área abaixo para comentários.</p><p>Até logo.</p><p><em>Originalmente publicado em O</em><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-2/"><em>bjectPascalProgramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98c9cbd87624" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Herança pode ser o Mal da Orientação a Objetos — Parte 1]]></title>
            <link>https://medium.com/@mdbs99/heran%C3%A7a-pode-ser-o-mal-da-orienta%C3%A7%C3%A3o-a-objetos-parte-1-35c4cee420bb?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/35c4cee420bb</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[object-pascal]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Tue, 24 May 2016 19:00:15 GMT</pubDate>
            <atom:updated>2016-05-24T19:00:15.615Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/896/0*cMx5VBk4NMRxXv8K.jpg" /></figure><p>Se você utiliza Herança em seu código, especificamente <strong>Herança de Classe</strong>, pode estar cometendo um <strong>erro</strong> terrível.</p><p>Com o uso da Herança você <strong>viola o encapsulamento</strong> de suas Classes, deixa seu código menos <strong>flexível</strong> e mais <strong>complexo</strong>.</p><p>Herança de Classe deve ser <strong>evitada</strong> a todo custo.</p><h3>Indrodução</h3><p>Se você já programa utilizando <strong>Orientação a Objetos</strong> há muito tempo, utilizando <strong>Classes e Subclasses</strong> em seu código para “reutilizar” funcionalidades, eu realmente <strong>não</strong> espero que você entenda e concorde comigo tão rapidamente.</p><p>Será necessário <strong>tempo</strong>.</p><p>Tempo para digerir as informações. Tempo para uma <strong>releitura</strong>. Tempo para <strong>pesquisas</strong> feitas por você mesmo. Tempo para ler sobre <strong>outras linguagens</strong>. Tempo para ler outros <strong>artigos e livros</strong>.</p><p>Depois você poderá formar sua opinião própria. Mas faça isso baseado em <strong>fatos</strong> e não baseado em <strong>preconceitos</strong> ou ignorância de informações.</p><p>No fim eu espero veementemente que você junte tudo isso e chegue a mesma conclusão que eu cheguei: <strong>Herança é o Mal</strong>.</p><p>E, claro, é importante saber que grandes empresas e desenvolvedores ao redor do mundo já chegaram a mesma conclusão faz muito tempo.</p><p>Mas porfavor, não pense que estou <strong>abolindo</strong> completamente a Herança. Estou lhe dizendo que ela é má, mas mesmo assim haverá momentos em que poderá ser mais <strong>simples</strong> ou eficiente utitilizá-la do que outra abordagem. Por exemplo, um médico pode tomar a decisão de amputar a perna de um paciente para mantê-lo vivo. Não é algo “bom” para se fazer se pensarmos somente na amputação, no entanto pode ser a melhor decisão se você pensar no todo — a sobrevivência do paciente.</p><p>É o mesmo com a Herança. Você tem essa possibilidade, mas só deverá utilizar em último recurso.</p><h3>Herança</h3><p>A Herança é um dos pilares da Orientação a Objetos, assim como <strong>Encapsulamento</strong> e <strong>Polimorfismo</strong>.</p><p>Se uma Classe B herda de A, então B <strong>é-um</strong> A. Herança é isso. As Subclasses serão substitutas mais especializadas de suas Super Classes.</p><p>Quando comecei a estudar Orientação a Objetos — 20 anos atrás — foi a primeira coisa que li. Esse era o mantra na época: <strong>Herança, Encapsulamento e Polimorfismo</strong>.</p><p>Para alguém como eu que só tinha visto <strong>código procedural</strong> em C ou Pascal, declarar uma Classe e Subclasses para herdar o comportamento reutilizando o código era… <strong>mágico</strong>.</p><p>Acho que Herança é o que mais <strong>impressiona</strong> quem está aprendendo — ou mesmo quem já é veterano — a programar Orientado a Objetos.</p><p>Com Herança o programador consegue extender uma Classe com novos métodos ou mesmo alterar o comportamento da Hierarquia com pouco código. Mágica.</p><p>E isso não é bom?!</p><p>Quase nunca.</p><p>Eu não entendi logo na primeira vez que li sobre “Herança ser ruim”. Eu já me considerava um desenvolvedor <strong>experiente</strong> em Orientação a Objetos, no entanto eu tive que mudar meus conceitos. Na verdade eu tive que <strong>reaprender</strong> o que era Orientação a Objetos. Não só por causa do uso da Herança, mas por causa de uma série de “novas” ideias que venho coletando, estududando e divulgando aqui mesmo, nesse blog.</p><p>E é por isso que eu acho que o mesmo deve acontecer à você, ou seja, mais cedo ou mais tarde você terá que mudar/atualizar seus conceitos sobre Orientação a Objetos. É inevitável.</p><p>Mas se você for uma pessoa mais <strong>sábia</strong> do que eu fui na época quando li sobre <strong>Herança ser ruim e que deve ser evitada</strong>, você poderá obter o benefício de ler sobre isso agora e não ter que perder tempo em busca de uma resposta para a <strong>dor</strong> que eu sei que você tem hoje, quando seu código começa a não fazer mais sentido; quando sua <strong>Hierarquia de Classes</strong> se torna um peso e atrapalha mais do que ajuda; quando você tem que sobrescrever métodos para não “fazer nada”, desabilitando funcionalidades; ou quando você tem que <strong>duplicar código</strong> porque sua Classe foi codificada numa “Hierarquia errada”.</p><h3>Os Males</h3><p>Se você nunca ouviu dizer que Herança é ruim, deve estar pensando que eu sou louco. Bem, saiba que eu não inventei tal afirmação. Gostaria de citar um artigo que encontrei na Internet há bastante tempo e que serviu de inspiração para o título desse artigo que você está lendo agora.</p><p>O <a href="http://www.javaworld.com/article/2073649/core-java/why-extends-is-evil.html">artigo</a> foi publicado na JavaWorld em <strong>1 de Agosto de 2003</strong>, intitulado: “<em>Why extends is evil</em>”.</p><p>Abaixo um pequeno trecho desse artigo. (Tradução Livre)</p><blockquote><em>Uma vez fui a uma reunião do grupo de usuários Java, onde James Gosling (inventor do Java) foi o orador de destaque. Durante o memorável Q&amp;A sessão, alguém lhe perguntou: “Se você pudesse fazer Java novamente, o que você mudaria?” “Eu deixaria de fora as Classes”, ele respondeu. Após sessarem os risos, ele explicou que o verdadeiro problema não era as Classes em si, mas sim a Herança de Implementação (extends). Herança de Interface (implements) é preferível. Você deve evitar a Herança de Implementação, sempre que possível. Why extends is evil — JavaWorld</em></blockquote><p>Nessa série de artigos vou tentar explicar os motivos porque eu — e milhares de desenvolvedores ao redor do mundo — considero Herança algo ruim e que deve ser evitada a todo custo.</p><p>Os principais motivos são:</p><ol><li>Viola o Encapsulamento</li><li>Duplicação de Código</li><li>Forte Acoplamento</li><li>Hierarquias Complexas</li></ol><h3>No próximo artigo…</h3><p>No próximo artigo irei explicar em detalhes porque a Herança Viola o Encapsulamento, com exemplos de código.</p><p><em>Originalmente publicado em </em><a href="http://objectpascalprogramming.com/posts/heranca-pode-ser-o-mal-da-orientacao-a-objetos-parte-1/"><em>ObjectPascalProgramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35c4cee420bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Singleton é um anti-padrão?]]></title>
            <link>https://medium.com/@mdbs99/singleton-%C3%A9-um-anti-padr%C3%A3o-52ed8a29d0ee?source=rss-6b9a93dfd800------2</link>
            <guid isPermaLink="false">https://medium.com/p/52ed8a29d0ee</guid>
            <category><![CDATA[medium-brasil]]></category>
            <category><![CDATA[brazil]]></category>
            <category><![CDATA[object-pascal]]></category>
            <dc:creator><![CDATA[Marcos Douglas B. Santos]]></dc:creator>
            <pubDate>Tue, 17 May 2016 18:14:01 GMT</pubDate>
            <atom:updated>2016-05-17T18:14:01.140Z</atom:updated>
            <content:encoded><![CDATA[<p>O padrão <em>Singleton</em> garante a existência de <strong>apenas uma instância</strong> de <strong>uma classe</strong>, mantendo <strong>um ponto global</strong> de acesso ao seu Objeto.</p><p>O <strong>conceito</strong> do <em>Singleton</em> não está errado, mas sua <strong>implementação</strong> clássica está.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*V0cjtdy8YUY26yfs.jpg" /></figure><p>Ter um <strong>ponto global de acesso</strong> é bom.</p><p>Garantir uma <strong>única instância</strong> para um Objeto, pode ser bom.</p><p>O <strong>erro</strong> é ter uma única instância de uma <strong>classe</strong>.</p><p>Por que?</p><p>Simples. Você não deve utilizar pontos globais com <strong>Referência Direta</strong> em seu código.</p><p>Quando digo Referência Direta quero dizer:</p><ul><li>Variáveis globais</li><li>Métodos estáticos que não trabalham com <em>Interfaces</em></li></ul><h3>Variáveis globais</h3><p>Você já deve saber que não devemos utilizar variáveis globais.</p><p>Seu uso é considerado um anti-padrão porque seu conteúdo pode ser modificado/acessado de qualquer parte do seu código. Haverá uma dependência direta dessa variável aumentando a complexidade do código. Qualquer alteração no valor dessa variável poderá ocasionar problemas em qualquer parte do código que a utilize.</p><h3>Métodos estáticos</h3><p>Um <a href="http://objectpascalprogramming.com/posts/nao-utilize-metodos-estaticos/">método estático</a> é acessado diretamente na Classe. Assim como uma variável global, o método estático é uma dependência direta e isso não é bom. No entanto o valor retornado por um método estático pode ser dinâmico. Pode ser um Objeto. Pode ser uma instância de uma <em>Interface</em>.</p><p>O <a href="http://objectpascalprogramming.com/posts/interfaces-e-o-metodo-estatico-new/">Método New()</a> é estático, mas seu retorno é dinâmico. Ele também retorna uma instância de uma <em>Interface</em> ao invés de um tipo primitivo ou Classe.</p><h3>O Padrão Singleton</h3><p>Um <a href="https://en.wikipedia.org/wiki/Singleton_pattern"><em>Singleton</em></a> utiliza uma variável global, que está encapsulada dentro da própria classe. Também utiliza um método estático, que irá retornar a instância única encapsulada na Classe. Essa instância é do tipo da própria Classe.</p><p>Precisamos utilizar esse Padrão?</p><p>Sim, por simplicidade.</p><p>Explico.</p><p>É possível nunca utilizar o <em>Singleton</em>. Basta você utilizar Injeção de Dependência nos <a href="http://objectpascalprogramming.com/posts/construtores-da-classe-primario-secundarios/">construtores</a> das Classes.</p><p>Mas para cada dependência teríamos que definir um argumento em todos os construtores, de todas as Classes, que necessitam utilizar a dependência.</p><p>Isso irá gerar <strong>Complexidade</strong> no código.</p><p>Você precisa de uma única instância de Objetos para:</p><ul><li>Conexão com um SGBD</li><li>Log de execução/<em>debugging</em></li><li>Configurações da Aplicação</li><li>Etc</li></ul><p>São exemplos. Na verdade eu posso querer utilizar um <em>pool</em> de conexões para o SGBD; ter várias Classes que representam as Configurações, etc. Mas, você entendeu.</p><p>Então garantir a existência de <strong>apenas uma instância</strong> mantendo <strong>um ponto global</strong> de acesso ao Objeto é importante. Isso minimiza a complexidade. Ao invés de ter sempre um parâmetro a mais em todos os construtores das Classes — ou da maioria delas — eu só preciso ter um único ponto de acesso para “algum” Objeto.</p><p>O <em>Singleton</em> clássico parece resolver isso. Sim, mas ele nos traz um problema maior do que o benefício.</p><h3>O Problema</h3><p>Não há como implementar um <em>Singleton</em> sem haver uma <strong>variável</strong> para retornar <strong>uma única instância</strong>.</p><p>O problema não é a variável, pois ela estará encapsulada na Classe. Isso quer dizer que ela estará protegida. Bem, talvez não tão protegida mas ainda melhor que uma variável global.</p><p>O problema também não é o <strong>método estático</strong> — mesmo tendo seu uso desencorajado na maioria dos casos — pois podemos retornar qualquer valor.</p><p>O <strong>real problema</strong> do Padrão <em>Singleton</em>, em sua implementação clássica, é o <strong>tipo de retorno</strong> do método estático.</p><h3>Implementação Clássica</h3><p>Existem variações de implementação do Padrão <em>Singleton</em> que utilizam algumas técnicas para inicializar a variável encapsulada, ou seja, a instância que será retornada pelo método estático que, na maioria das vezes, é denominado GetInstance.</p><p>Na implementação mais básica, que pode ser feita em praticamente qualquer linguagem Orientada a Objetos, implementamos construtores da Classe como privados. Assim o utilizador da Classe não conseguirá instanciar Objetos dessa Classe diretamente. Depois é definido um (ou mais) método estático — GetInstance — para retornar uma instância da Classe… do mesmo tipo da Classe!</p><p>Aí está o problema.</p><p>Um <strong>grave</strong> problema.</p><p>Se você retornar uma instância do mesmo tipo da Classe, seu código terá uma dependência direta com essa Classe. Só isso pode arruinar qualquer tentativa de testes automatizados no código.</p><p>Veja um exemplo:</p><pre>procedure TUserAction.ChangePassword(<br>  User: IUser; const NewPassword: string);<br>begin<br>  if NewPassword = &#39;&#39; then<br>    raise Exception.Create(&#39;Invalid Password&#39;);<br>  if Length(NewPassword) &lt; 8 then<br>    raise Exception.Create(&#39;Must have 8 characters or more&#39;);<br>  User.Password := NewPassword;<br>  TMSSQL.GetInstance.Save(User);<br>end;</pre><p>É um código idiota, mas serve ao propósito.</p><p>Vejamos.</p><p>Existe um Classe TUserAction que tem um método para alterar o <em>password</em> do usuário logado. Esse método tem algumas validações simples.</p><p>Alteramos seu <em>password</em> e depois essa alteração será persistida no SGBD.</p><p>A chamada TMSSQL.GetInstance é um <em>Singleton</em>. O método irá retornar uma conexão TMSSQLConnection para o MSSQL.</p><p>Utilizamos então o método Save(User) para persistir as alterações.</p><p>Não importa como Save(User) sabe como persistir um usuário. Isso não é relevante. O problema aqui é como iremos testar ChangePassword sem fazer a integração/conexão real com o SGBD (MSSQL).</p><p>Eu só quero testar o método utilizando um <strong>teste automatizado</strong>. Eu não quero ter que conectar num SGBD real, utilizar <em>user/password</em> reais e muito menos alterar algum dado.</p><p>Quero fazer <strong>testes de unidade</strong>, não <strong>testes de integração</strong>.</p><p>Bem, se TMSSQL.GetInstance me retorna uma instância de TMSSQLConnection, uma Classe concreta, <strong>não é possível fazer o teste automatizado</strong>.</p><p>É um exemplo simples. Vejo isso na maioria dos códigos “<em>Object Pascal</em>” — que não tem nada de Orientação a Objetos.</p><p>Na verdade, a maioria iria utilizar uma instância de algum <a href="http://objectpascalprogramming.com/posts/datamodule-e-apenas-um-container/">DataModule</a> e iria substituir a chamada TMSSQL.GetInstance por apenas DM.conMSSQL ou seja, duas variáveis. Triste.</p><p>Entendeu por que não devemos utilizar uma instância de Classe concreta?</p><p>E qual a solução?</p><p>Retornar uma instância de <a href="http://objectpascalprogramming.com/posts/interfaces-em-todo-lugar/">Interface</a> ao invés de uma instância do tipo Classe.</p><h3>Implementação Sugerida</h3><p>O que irei sugerir para a implementação de um <em>Singleton</em> é tão simples quanto parece, mas com um ganho incontestável: <strong>Desacoplamento</strong>.</p><p>Utilize <em>Interfaces</em>.</p><p>Ao invés de TMSSQL.GetInstance retornar um TMSSQLConnection, o método irá retornar um IConnection ou seja, uma <em>Interface</em>.</p><p>Se agora temos um retorno que é uma <em>Interface</em>, podemos ter qualquer Classe que implemente essa <em>Interface</em>.</p><p>A Classe TMSSQLConnection deverá implementar IConnection.</p><p>E onde está desacoplamento?</p><p>Você poderá retornar qualquer instância que implemente IConnection e isso pode ser feito de várias formas.</p><p>Se quiser escrever menos, utilize <strong>diretivas de compilação</strong>.</p><pre>class function TMSSQL.GetInstance: IConnection;<br>begin<br>  if not Assigned(FInstance) then<br>  begin<br>    <em>{$IFDEF TEST}</em><br>      FInstance := TFakeConnection.Create;<br>    <em>{$ELSE}</em><br>      FInstance := TMSSQLConnection.Create(&#39;user&#39;, &#39;password&#39;);<br>    <em>{$ENDIF}</em><br>  end;<br>  Result := FInstance;<br>end;</pre><p>Essa é a maneira “Rápido e sujo”. Você pode começar por aí caso nunca tenha pensado nisso. Quando estiver em “modo de teste”, ative a diretiva TEST, do contrário a Classe de produção será utilizada.</p><p>A Classe TFakeConnection não se conecta em nenhum SGBD. Talvez você possa utilizá-la para fazer um log das instruções SQL ou <strong>não fazer nada</strong> quando chamar o método Save.</p><p>Se você está testando as <strong>Regras de Negócio</strong>, a persistência é irrelevante.</p><p>Depois você pode <strong>refatorar</strong> esse código e deixá-lo mais Orientado a Objetos, utilizando Injeção de Dependência em conjunto com <a href="https://en.wikipedia.org/wiki/Abstract_factory_pattern"><em>Abstract Factory Pattern</em></a>.</p><p>Como?</p><p>Bem, em algum lugar no seu código você deverá ter uma chamada para “inicializar” a Classe TMSSQL.</p><pre>class function TMSSQL.Initialize(Factory: IConnectionFactory);<br>begin<br>  FFactory := Factory;<br>end;<br><br>initialization<br>  TMSSQL.Initialize(TDbConnectionFactory.New(&#39;mssql&#39;));<br><br>end.</pre><p>Mais um vez estaremos utilizando métodos estáticos. Mas estamos em busca de simplicidade. Não devemos ser <strong>puristas</strong> em Orientação a Objetos se não há nenhum benefício. Sempre haverá partes do código que poderiam melhorar, refatorar, eliminar, etc. Enfim.</p><p>A Classe TMSSQL deverá ser bem pequena e sem complexidade.</p><p>O atributo FFactory é um class var assim como FInstance.</p><p>Então você poderá ter novas Classes que implementam IConnectionFactory.</p><p>No exemplo temos TDbConnectionFactory. Optei por utilizar um parâmetro que me diz qual “tipo” de Classe será utilizada. Se eu quiser testar o código bastaria chamar TDbConnectionFactory.New(‘test’).</p><p>Utilize seu estilo.</p><p>Após essa alteração o método GetInstance pode ser refatorado:</p><pre>class function TMSSQL.GetInstance: IConnection;<br>begin<br>  if not Assigned(FInstance) then<br>    FInstance := FFactory.NewConnection(FUser, FPassword);<br>  Result := FInstance;<br>end;</pre><p>A chamada a FFactory.NewConnection irá gerar uma nova instância de IConnection. Qual a Classe que estará sendo utilizada é irrelevante para o código que utiliza TMSSQL.GetInstance em todos os lugares, como deve ser. O retorno poderia ser TMSSQLConnection, TFakeConnection ou qualquer outra classe que implemente IConnection.</p><p>Esse é um <em>Singleton</em> <strong>simples</strong>, <strong>desacoplado</strong> e <strong>Orientado a Objetos</strong>.</p><p>Até logo.</p><p><em>Originalmente publicado em O</em><a href="http://objectpascalprogramming.com/posts/singleton-e-um-anti-padrao/"><em>bjectPascalProgramming.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52ed8a29d0ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>