{"id":769,"date":"2024-07-22T14:20:11","date_gmt":"2024-07-22T17:20:11","guid":{"rendered":"https:\/\/adrianosantostreina.com.br\/blog\/?p=769"},"modified":"2024-08-19T13:41:48","modified_gmt":"2024-08-19T16:41:48","slug":"codigo-limpo-parte-6-estrutura-de-classes-e-objetos","status":"publish","type":"post","link":"https:\/\/adrianosantostreina.com.br\/blog\/codigo-limpo-parte-6-estrutura-de-classes-e-objetos\/","title":{"rendered":"C\u00f3digo-Limpo Parte 6: Estrutura de Classes e Objetos"},"content":{"rendered":"\n

A estrutura de classes e objetos \u00e9 fundamental para a cria\u00e7\u00e3o de um c\u00f3digo-limpo e de f\u00e1cil manuten\u00e7\u00e3o. Uma boa estrutura\u00e7\u00e3o garante que o c\u00f3digo seja modular, reutiliz\u00e1vel e f\u00e1cil de entender. Seguir os princ\u00edpios de design de classes e objetos ajuda a criar sistemas que s\u00e3o mais robustos e flex\u00edveis, facilitando a adi\u00e7\u00e3o de novas funcionalidades e a corre\u00e7\u00e3o de bugs. Este artigo explora as melhores pr\u00e1ticas para a estrutura\u00e7\u00e3o de classes e objetos em Delphi, destacando a import\u00e2ncia da coes\u00e3o e do baixo acoplamento.<\/p>\n\n\n\n\n\n\n\n

A Import\u00e2ncia da Estrutura de Classes e Objetos<\/h4>\n\n\n\n

Classes e objetos s\u00e3o os blocos de constru\u00e7\u00e3o de sistemas orientados a objetos. Uma estrutura bem planejada traz diversos benef\u00edcios:<\/p>\n\n\n\n

    \n
  1. Manuten\u00e7\u00e3o<\/strong>: Facilita a manuten\u00e7\u00e3o e a atualiza\u00e7\u00e3o do c\u00f3digo, permitindo que mudan\u00e7as sejam feitas de forma isolada.<\/li>\n\n\n\n
  2. Reutiliza\u00e7\u00e3o<\/strong>: Classes bem projetadas podem ser reutilizadas em diferentes partes do sistema ou mesmo em outros projetos.<\/li>\n\n\n\n
  3. Legibilidade<\/strong>: Um c\u00f3digo bem estruturado \u00e9 mais f\u00e1cil de ler e entender, o que \u00e9 crucial para a colabora\u00e7\u00e3o entre desenvolvedores.<\/li>\n\n\n\n
  4. Flexibilidade<\/strong>: Facilita a adi\u00e7\u00e3o de novas funcionalidades sem a necessidade de grandes reestrutura\u00e7\u00f5es no c\u00f3digo existente.<\/li>\n<\/ol>\n\n\n\n

    Princ\u00edpios de Design de Classes e Objetos<\/h4>\n\n\n\n
      \n
    1. Coes\u00e3o<\/strong>: Uma classe deve ter uma \u00fanica responsabilidade bem definida. Classes coesas s\u00e3o mais f\u00e1ceis de entender e modificar.<\/li>\n<\/ol>\n\n\n\n

      Entendendo melhor a Coes\u00e3o<\/strong>: Coes\u00e3o refere-se ao grau em que os elementos de uma classe est\u00e3o relacionados e trabalham juntos para uma \u00fanica finalidade. Uma classe altamente coesa possui m\u00e9todos e propriedades que est\u00e3o diretamente relacionados \u00e0 sua responsabilidade principal, o que facilita a manuten\u00e7\u00e3o e a expans\u00e3o do c\u00f3digo. Por exemplo, uma classe TCliente<\/code> deve lidar apenas com informa\u00e7\u00f5es e comportamentos relacionados a um cliente, como nome, endere\u00e7o e m\u00e9todos para atualizar essas informa\u00e7\u00f5es.<\/p>\n\n\n\n

        \n
      1. Baixo Acoplamento<\/strong>: Classes devem ser o mais independentes poss\u00edvel umas das outras. Isso facilita a manuten\u00e7\u00e3o e a reutiliza\u00e7\u00e3o do c\u00f3digo.<\/li>\n<\/ol>\n\n\n\n

        Melhor explicando Baixo Acoplamento<\/strong>: Acoplamento refere-se ao grau de depend\u00eancia entre classes. O baixo acoplamento \u00e9 desej\u00e1vel porque mudan\u00e7as em uma classe t\u00eam menos probabilidade de impactar outras classes, tornando o sistema mais robusto e f\u00e1cil de modificar. Para alcan\u00e7ar baixo acoplamento, utilize interfaces e abstra\u00e7\u00f5es, permitindo que classes se comuniquem atrav\u00e9s de contratos definidos em vez de implementa\u00e7\u00f5es concretas.<\/p>\n\n\n\n

          \n
        1. Encapsulamento<\/strong>: Detalhes internos da classe devem ser escondidos do mundo exterior. Apenas m\u00e9todos p\u00fablicos e propriedades devem ser acess\u00edveis externamente.<\/li>\n<\/ol>\n\n\n\n

          Um pouco mais sobre Encapsulamento<\/strong>: Encapsulamento \u00e9 a pr\u00e1tica de esconder os detalhes internos de uma classe e expor apenas o necess\u00e1rio. Isso protege os dados da classe de acesso e modifica\u00e7\u00e3o direta, permitindo mudan\u00e7as internas sem afetar outras partes do sistema. Utilizar propriedades (getters e setters) em vez de expor vari\u00e1veis diretamente \u00e9 uma pr\u00e1tica comum de encapsulamento.<\/p>\n\n\n\n

            \n
          1. Heran\u00e7a e Polimorfismo<\/strong>: Utilize heran\u00e7a para reutilizar c\u00f3digo e polimorfismo para criar sistemas flex\u00edveis e extens\u00edveis.<\/li>\n<\/ol>\n\n\n\n

            Sobre Heran\u00e7a e Polimorfismo<\/strong>: Heran\u00e7a permite que uma classe derive de outra, reutilizando c\u00f3digo comum e facilitando a cria\u00e7\u00e3o de hierarquias de classes. Polimorfismo permite que m\u00e9todos de classes derivadas sejam chamados atrav\u00e9s de refer\u00eancias da classe base, proporcionando flexibilidade e extensibilidade. Em Delphi, use heran\u00e7a com parcim\u00f4nia e prefira a composi\u00e7\u00e3o quando apropriado para evitar hierarquias complexas e dif\u00edceis de manter.<\/p>\n\n\n\n

            \"\"<\/a><\/figure>\n\n\n\n

            Implementa\u00e7\u00e3o de Estrutura de Classes e Objetos em Delphi<\/h4>\n\n\n\n

            Exemplo de Estrutura\u00e7\u00e3o de Classes:<\/strong><\/p>\n\n\n\n

            Antes<\/strong>:<\/p>\n\n\n\n

            type\n  TCliente = class\n  public\n    Nome: string;\n    Idade: Integer;\n    procedure ExibirDetalhes;\n  end;\n\n  TPedido = class\n  public\n    Numero: Integer;\n    Valor: Currency;\n    procedure ExibirPedido;\n  end;\n\nprocedure TCliente.ExibirDetalhes;\nbegin\n  ShowMessage('Nome: ' + Nome + ' Idade: ' + IntToStr(Idade));\nend;\n\nprocedure TPedido.ExibirPedido;\nbegin\n  ShowMessage('N\u00famero do Pedido: ' + IntToStr(Numero) + ' Valor: ' + CurrToStr(Valor));\nend;\n<\/pre><\/div>\n\n\n\n
            Depois<\/strong>:<\/p>\n\n\n\n
            type\n  TCliente = class\n  private\n    FNome: string;\n    FIdade: Integer;\n  public\n    constructor Create(const ANome: string; AIdade: Integer);\n    procedure ExibirDetalhes;\n    property Nome: string read FNome write FNome;\n    property Idade: Integer read FIdade write FIdade;\n  end;\n\n  TPedido = class\n  private\n    FNumero: Integer;\n    FValor: Currency;\n  public\n    constructor Create(ANumero: Integer; AValor: Currency);\n    procedure ExibirPedido;\n    property Numero: Integer read FNumero write FNumero;\n    property Valor: Currency read FValor write FValor;\n  end;\n\nconstructor TCliente.Create(const ANome: string; AIdade: Integer);\nbegin\n  FNome := ANome;\n  FIdade := AIdade;\nend;\n\nprocedure TCliente.ExibirDetalhes;\nbegin\n  ShowMessage('Nome: ' + FNome + ' Idade: ' + IntToStr(FIdade));\nend;\n\nconstructor TPedido.Create(ANumero: Integer; AValor: Currency);\nbegin\n  FNumero := ANumero;\n  FValor := AValor;\nend;\n\nprocedure TPedido.ExibirPedido;\nbegin\n  ShowMessage('N\u00famero do Pedido: ' + IntToStr(FNumero) + ' Valor: ' + CurrToStr(FValor));\nend;\n<\/pre><\/div>\n\n\n\n
            Melhorias:<\/strong><\/p>\n\n\n\n
              \n
            1. Encapsulamento<\/strong>: Os campos das classes s\u00e3o privados e acessados por meio de propriedades, garantindo que os detalhes internos estejam ocultos.<\/li>\n\n\n\n
            2. Construtores<\/strong>: Construtores s\u00e3o usados para inicializar objetos, assegurando que todas as propriedades necess\u00e1rias sejam definidas.<\/li>\n\n\n\n
            3. Coes\u00e3o<\/strong>: Cada classe tem uma responsabilidade clara e bem definida.<\/li>\n<\/ol>\n\n\n\n
              Uma boa estrutura de classes e objetos \u00e9 essencial para a cria\u00e7\u00e3o de software robusto, flex\u00edvel e f\u00e1cil de manter. Ao seguir os princ\u00edpios de coes\u00e3o, baixo acoplamento e encapsulamento, e ao utilizar heran\u00e7a e polimorfismo de maneira adequada, voc\u00ea pode garantir que seu c\u00f3digo seja limpo e sustent\u00e1vel. <\/p>\n\n\n\n
              Uso de Interfaces em Delphi<\/h3>\n\n\n\n
              Outro ponto importante s\u00e3o as Interfaces. Interfaces s\u00e3o um conceito poderoso em programa\u00e7\u00e3o orientada a objetos que permite definir contratos para classes sem especificar a implementa\u00e7\u00e3o. Em Delphi, as interfaces s\u00e3o usadas para garantir baixo acoplamento e alta coes\u00e3o, promovendo um design flex\u00edvel e reutiliz\u00e1vel.<\/p>\n\n\n\n
              O que s\u00e3o Interfaces?<\/h4>\n\n\n\n
              Uma interface \u00e9 um tipo que define um conjunto de m\u00e9todos, propriedades e eventos que uma classe deve implementar, mas n\u00e3o fornece a implementa\u00e7\u00e3o desses membros. As interfaces permitem que diferentes classes implementem a mesma interface de maneiras distintas, fornecendo flexibilidade e promovendo o princ\u00edpio de baixo acoplamento.<\/p>\n\n\n\n
              Vantagens do uso de Interfaces<\/h4>\n\n\n\n
                \n
              1. Baixo Acoplamento<\/strong>: Interfaces permitem que as classes se comuniquem atrav\u00e9s de contratos, em vez de implementa\u00e7\u00f5es espec\u00edficas, reduzindo a depend\u00eancia entre elas.<\/li>\n\n\n\n
              2. Flexibilidade<\/strong>: Mudar a implementa\u00e7\u00e3o de uma interface n\u00e3o afeta as classes que a utilizam, facilitando a manuten\u00e7\u00e3o e a expans\u00e3o do sistema.<\/li>\n\n\n\n
              3. Reutiliza\u00e7\u00e3o<\/strong>: Interfaces podem ser implementadas por v\u00e1rias classes, promovendo a reutiliza\u00e7\u00e3o de c\u00f3digo.<\/li>\n<\/ol>\n\n\n\n
                Implementa\u00e7\u00e3o de Interfaces em Delphi<\/h4>\n\n\n\n
                Defini\u00e7\u00e3o de Interfaces:<\/strong><\/p>\n\n\n\n
                type\n  ICliente = interface\n    ['{E8C7E9B6-1F0A-4C70-945D-8D7451E2A711}']\n    function GetNome: string;\n    function GetIdade: Integer;\n    procedure ExibirDetalhes;\n    property Nome: string read GetNome;\n    property Idade: Integer read GetIdade;\n  end;\n\n  IPedido = interface\n    ['{76A6B0BA-8D5B-49A3-AE55-90F6BC13F2A2}']\n    function GetNumero: Integer;\n    function GetValor: Currency;\n    procedure ExibirPedido;\n    property Numero: Integer read GetNumero;\n    property Valor: Currency read GetValor;\n  end;\n<\/pre><\/div>\n\n\n\n
                Uso:<\/strong><\/p>\n\n\n\n
                type\n  TCliente = class(TInterfacedObject, ICliente)\n  private\n    FNome: string;\n    FIdade: Integer;\n  public\n    constructor Create(const ANome: string; AIdade: Integer);\n    function GetNome: string;\n    function GetIdade: Integer;\n    procedure ExibirDetalhes;\n  end;\n\n  TPedido = class(TInterfacedObject, IPedido)\n  private\n    FNumero: Integer;\n    FValor: Currency;\n  public\n    constructor Create(ANumero: Integer; AValor: Currency);\n    function GetNumero: Integer;\n    function GetValor: Currency;\n    procedure ExibirPedido;\n  end;\n\nconstructor TCliente.Create(const ANome: string; AIdade: Integer);\nbegin\n  FNome := ANome;\n  FIdade := AIdade;\nend;\n\nfunction TCliente.GetNome: string;\nbegin\n  Result := FNome;\nend;\n\nfunction TCliente.GetIdade: Integer;\nbegin\n  Result := FIdade;\nend;\n\nprocedure TCliente.ExibirDetalhes;\nbegin\n  ShowMessage('Nome: ' + FNome + ' Idade: ' + IntToStr(FIdade));\nend;\n\nconstructor TPedido.Create(ANumero: Integer; AValor: Currency);\nbegin\n  FNumero := ANumero;\n  FValor := AValor;\nend;\n\nfunction TPedido.GetNumero: Integer;\nbegin\n  Result := FNumero;\nend;\n\nfunction TPedido.GetValor: Currency;\nbegin\n  Result := FValor;\nend;\n\nprocedure TPedido.ExibirPedido;\nbegin\n  ShowMessage('N\u00famero do Pedido: ' + IntToStr(FNumero) + ' Valor: ' + CurrToStr(FValor));\nend;\n<\/pre><\/div>\n\n\n\n
                Interfaces s\u00e3o uma ferramenta poderosa para criar sistemas flex\u00edveis e de baixo acoplamento. Em Delphi, elas permitem definir contratos claros para as classes, promovendo a reutiliza\u00e7\u00e3o e a manuten\u00e7\u00e3o do c\u00f3digo. Implementar interfaces de maneira adequada ajuda a criar um software mais robusto e sustent\u00e1vel.<\/p>\n\n\n\n
                Conclus\u00e3o<\/h3>\n\n\n\n
                A estrutura\u00e7\u00e3o adequada de classes e objetos \u00e9 essencial para criar um software robusto, flex\u00edvel e f\u00e1cil de manter. Neste artigo, exploramos a import\u00e2ncia de seguir princ\u00edpios como coes\u00e3o, baixo acoplamento, encapsulamento e o uso de heran\u00e7a e polimorfismo. Discutimos tamb\u00e9m o papel crucial das interfaces em promover um design flex\u00edvel e de baixo acoplamento, permitindo que diferentes implementa\u00e7\u00f5es sejam substitu\u00eddas sem impactar outras partes do sistema. Implementar essas pr\u00e1ticas em Delphi garante que o c\u00f3digo seja limpo, sustent\u00e1vel e preparado para futuras expans\u00f5es e manuten\u00e7\u00f5es.<\/p>\n\n\n\n
                Utilizar interfaces, encapsular dados e seguir os princ\u00edpios de design orientado a objetos n\u00e3o apenas melhora a legibilidade e a manuten\u00e7\u00e3o do c\u00f3digo, mas tamb\u00e9m facilita a colabora\u00e7\u00e3o entre desenvolvedores. Ao aderir a essas pr\u00e1ticas, voc\u00ea cria um ambiente de desenvolvimento mais eficiente e produtivo, capaz de evoluir com as necessidades do projeto. No pr\u00f3ximo artigo, exploraremos o s\u00e9timo pilar do c\u00f3digo-limpo: Testes Automatizados.<\/p>\n\n\n\n
                Comunidade no Telegram<\/a><\/p>\n\n\n\n
                \ud83d\ude80Comente no campo abaixo \ud83d\udc47\ud83d\udc47\ud83d\udc47 o que achou e qual sua d\u00favida.<\/p>\n\n\n\n
                Te vejo na pr\u00f3xima<\/p>\n\n\n\n
                Adriano Santos<\/p>\n\n\n\n
                <\/p>\n\n\n\n
                Demais Artigos:<\/strong><\/p>\n\n\n\n
                Parte 1: Nomes Significativos<\/a>
                Parte 2: Fun\u00e7\u00f5es Pequenas<\/a>
                Parte 3: Coment\u00e1rios Eficientes<\/a>
                Parrte 4: Formata\u00e7\u00e3o Consistente<\/a>
                Parte 5: Tratamento de Erros<\/a>
                Parte 6: Estrutura de Classes<\/a>
                Parte 7: Testes Automatizados<\/a>
                Parte 8: Refatora\u00e7\u00e3o Cont\u00ednua<\/a>
                Parte 9: C\u00f3digo Simples e Direto<\/a>
                Parte 10: SOLID<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
                A estrutura de classes e objetos \u00e9 fundamental para a cria\u00e7\u00e3o de um c\u00f3digo-limpo e de f\u00e1cil manuten\u00e7\u00e3o. Uma boa estrutura\u00e7\u00e3o garante que o c\u00f3digo seja modular, reutiliz\u00e1vel e f\u00e1cil de entender. Seguir os princ\u00edpios de design de classes e objetos ajuda a criar sistemas que s\u00e3o mais robustos e flex\u00edveis, facilitando a adi\u00e7\u00e3o de […]<\/p>\n","protected":false},"author":1,"featured_media":773,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-769","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog"],"_links":{"self":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/769","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/comments?post=769"}],"version-history":[{"count":4,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/769\/revisions"}],"predecessor-version":[{"id":815,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/769\/revisions\/815"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/media\/773"}],"wp:attachment":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/media?parent=769"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/categories?post=769"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/tags?post=769"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}