{"id":3953,"date":"2021-01-22T15:44:14","date_gmt":"2021-01-22T14:44:14","guid":{"rendered":"https:\/\/gdksoftware.com\/knowledgebase\/solid-principles-in-delphi-1-the-single-responsibility-principle"},"modified":"2023-02-17T16:48:49","modified_gmt":"2023-02-17T15:48:49","slug":"principios-solid-em-delphi-o-principio-da-responsabilidade-unica","status":"publish","type":"knowledge","link":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica","title":{"rendered":"Princ\u00edpios SOLID em Delphi [1] – O Princ\u00edpio da Responsabilidade \u00danica"},"content":{"rendered":"

Princ\u00edpio da responsabilidade \u00fanica<\/h4>\n

Hoje, vamos mergulhar no S<\/strong> dos SOLID Princ\u00edpios: O Princ\u00edpio da Responsabilidade \u00danica. Mas antes de come\u00e7armos, apenas uma r\u00e1pida atualiza\u00e7\u00e3o sobre o SOLID.<\/p>\n

SOLID \u00e9 um acr\u00f4nimo para um conjunto de cinco princ\u00edpios de desenvolvimento de software que, se seguidos, se destinam a ajudar os desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo. Os cinco princ\u00edpios s\u00e3o:<\/p>\n

O princ\u00edpio da responsabilidade \u00fanica<\/strong> \u2014 As classes devem ter uma \u00fanica responsabilidade e, portanto, apenas um \u00fanico motivo para mudar.<\/p>\n

O princ\u00edpio aberto\/fechado<\/strong> \u2014 As classes e outras entidades devem ser abertas para extens\u00e3o, mas fechadas para modifica\u00e7\u00e3o.<\/p>\n

O Princ\u00edpio de Substitui\u00e7\u00e3o Liskov<\/strong> \u2014 Os objetos devem ser substitu\u00edveis por seus subtipos.<\/p>\n

O princ\u00edpio de segrega\u00e7\u00e3o da interface<\/strong> \u2014 Os clientes n\u00e3o devem ser for\u00e7ados a depender de interfaces que n\u00e3o utilizam.<\/p>\n

O Princ\u00edpio da Invers\u00e3o de Depend\u00eancia<\/strong> \u2014 Depende mais das abstra\u00e7\u00f5es do que das concre\u00e7\u00f5es.<\/p>\n

\n

Portanto, o princ\u00edpio da responsabilidade \u00fanica. Como o nome sugere, cada classe em um programa deve ter uma \u00fanica responsabilidade por apenas uma parte da funcionalidade do programa. Mas isso parece mais f\u00e1cil do que \u00e9. O que \u00e9 exatamente uma parte de um programa, e como saber quando separar a funcionalidade? \u00c9 muito simples dizer que uma classe s\u00f3 deve fazer uma coisa.<\/p>\n

Robert C. Martin expressa o princ\u00edpio como “Reunir as coisas que mudam pelas mesmas raz\u00f5es”. Separar as coisas que mudam por diferentes raz\u00f5es”<\/strong>, e mais recentemente “Este princ\u00edpio \u00e9 sobre as pessoas<\/a>“. Isso deve nos indicar a dire\u00e7\u00e3o correta.<\/p>\n

Quando voc\u00ea escreve um m\u00f3dulo de software, voc\u00ea quer ter certeza de que quando as mudan\u00e7as s\u00e3o solicitadas, essas mudan\u00e7as s\u00f3 podem se originar de uma \u00fanica pessoa, ou de um \u00fanico grupo estreitamente acoplado de pessoas representando uma \u00fanica fun\u00e7\u00e3o empresarial estritamente definida. Isto significa que um m\u00f3dulo ou classe de software deve ter uma responsabilidade para esse grupo particular de pessoas.<\/strong><\/p>\n

\u00c9 mais f\u00e1cil explicar isto por meio de um exemplo. Vamos dar uma olhada nesta classe a seguir:<\/p>\n

\n
type<\/span>\r\n  TShip =<\/span> class<\/span>\r\n  private<\/span>\r\n    FPosition:<\/span> TPoint;<\/span>\r\n    FHeading:<\/span> Integer<\/span>;<\/span>\r\n    FSpeed:<\/span> Integer<\/span>;<\/span>\r\n    FCargoLoad:<\/span> string<\/span>;<\/span>\r\n  public<\/span>\r\n    procedure<\/span> SetHeading<\/span>(NewHeading:<\/span> Integer<\/span>);<\/span>\r\n    procedure<\/span> SetSpeed<\/span>(NewSpeed:<\/span> Integer<\/span>);<\/span>\r\n    function<\/span> GetCoordinate<\/span>:<\/span> TPoint;<\/span>\r\n    procedure<\/span> PlotCourse<\/span>;<\/span>\r\n    procedure<\/span> LoadCargo<\/span>(NewCargo:<\/span> string<\/span>);<\/span>\r\n    procedure<\/span> PrintCargo<\/span>;<\/span>\r\n    procedure<\/span> ReportPosition<\/span>;<\/span>\r\n    procedure<\/span> CalculateProfit<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Esta \u00e9 uma classe que est\u00e1 fazendo um par de coisas, tudo sobre administrar a posi\u00e7\u00e3o e o curso de um navio, sua carga e algumas coisas para relatar. Como este \u00e9 um breve exemplo para mostrar como pensar sobre o Princ\u00edpio de Responsabilidade \u00danica, n\u00e3o preste muita aten\u00e7\u00e3o aos detalhes do c\u00f3digo em si; trata-se de uma grande vis\u00e3o geral da estrutura desta classe em particular.<\/p>\n
Acho que todos n\u00f3s conhecemos este tipo de classe de “Deus”. Normalmente, repletas de muita funcionalidade e c\u00f3digo, e gerenciando uma parte ou m\u00f3dulo em particular de seu programa. A quest\u00e3o \u00e9, se precisamos fazer algumas mudan\u00e7as nesta classe, como podemos refatorar esta classe para ter certeza de reunir as coisas que mudam pelo mesmo motivo, e separar aquelas coisas que mudam por diferentes motivos.<\/p>\n
Vamos parar por um momento e pensar sobre as responsabilidades deste c\u00f3digo em rela\u00e7\u00e3o ao (grupo de) pessoas. Podemos definir um par de pessoas espec\u00edficas que ter\u00e3o alguma responsabilidade com rela\u00e7\u00e3o \u00e0 administra\u00e7\u00e3o do navio, dire\u00e7\u00e3o e rumo, e ferramentas de relat\u00f3rio. Portanto, digamos que neste caso definamos um capit\u00e3o, um navegador, um comandante de carga e um gerente financeiro. Se voc\u00ea pensar nestas diferentes fun\u00e7\u00f5es, de repente \u00e9 muito f\u00e1cil separar esta classe em diferentes m\u00f3dulos, com apenas uma responsabilidade para essa fun\u00e7\u00e3o em particular. Devemos ter uma classe para definir o rumo e a pot\u00eancia (capit\u00e3o), uma para gerenciar a posi\u00e7\u00e3o e tra\u00e7ar o rumo do navio (navegador), uma para gerenciar a carga deste navio (comandante da carga) e uma para todos os nossos relat\u00f3rios (financeiro) (gerente financeiro).<\/p>\n
Nossas novas classes podem agora se parecer com isto:<\/p>\n
\n
type<\/span>\r\n  TShipLocation =<\/span> class<\/span>\r\n  private<\/span>\r\n    FPosition:<\/span> TPoint;<\/span>\r\n  public<\/span>\r\n    function<\/span> GetCoordinate<\/span>:<\/span> TPoint;<\/span>\r\n    procedure<\/span> PlotCourse<\/span>;<\/span>\r\n    procedure<\/span> ReportPosition<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TShipMovement =<\/span> class<\/span>\r\n  private<\/span>\r\n    FHeading:<\/span> Integer<\/span>;<\/span>\r\n    FSpeed:<\/span> Integer<\/span>;<\/span>\r\n  public<\/span>\r\n    procedure<\/span> SetHeading<\/span>(NewHeading:<\/span> Integer<\/span>);<\/span>\r\n    procedure<\/span> SetSpeed<\/span>(NewSpeed:<\/span> Integer<\/span>);<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TCargo =<\/span> class<\/span>\r\n  private<\/span>\r\n    FCargoLoad:<\/span> string<\/span>;<\/span>\r\n  public<\/span>\r\n    procedure<\/span> LoadCargo<\/span>(NewCargo:<\/span> string<\/span>);<\/span>\r\n    procedure<\/span> PrintCargo<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TShipReport =<\/span> class<\/span>\r\n  public<\/span>\r\n    procedure<\/span> CalculateProfit<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TShip =<\/span> class<\/span>\r\n  private<\/span>\r\n  public<\/span>\r\n    \/\/ reference to subclasses<\/span>\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Voc\u00ea teria feito o mesmo se n\u00e3o tivesse pensado nas pessoas por tr\u00e1s das responsabilidades da classe? Talvez, mas eu posso imaginar que a classe ShipLocation e ShipMovement poderiam ter acabado na mesma classe.<\/p>\n
Ent\u00e3o, o que acontece agora se recebermos um pedido do capit\u00e3o para adicionar um propulsor de proa para facilitar a condu\u00e7\u00e3o do navio em pequenos canais? Basta fazer esta mudan\u00e7a na classe ShipMovement, sem afetar nenhuma das outras classes. E se quisermos implementar um novo sistema de carregamento de carga? Basta alterar a classe Cargo, novamente sem tocar em nenhuma das outras classes.<\/p>\n
Espero que agora voc\u00ea veja porque o princ\u00edpio da responsabilidade \u00fanica \u00e9 realmente sobre pessoas, ou atores, e a responsabilidade da funcionalidade dos m\u00f3dulos ou classes de seu programa em rela\u00e7\u00e3o a essas pessoas. E, claro, voc\u00ea pode aplicar isto em diferentes n\u00edveis de seu programa, desde m\u00f3dulos a classes at\u00e9 fun\u00e7\u00f5es espec\u00edficas.<\/p>\n
Se voc\u00ea sempre tiver este princ\u00edpio em mente ao refatorar ou projetar um m\u00f3dulo ou classe, tenho certeza de que seu c\u00f3digo ser\u00e1 melhor mantido e \u00e9 f\u00e1cil de mudar.<\/p>\n
Torne-se um her\u00f3i da GDK Delphi! Subscreva aqui para nossa lista de correio da Delphi!<\/a><\/p>\n","protected":false},"featured_media":0,"parent":0,"template":"","class_list":["post-3953","knowledge","type-knowledge","status-publish","hentry","knowledge-category-arquivo-delphi","knowledge-category-desenvolvimento-de-software"],"acf":{"author":1398,"type_hero":"compact","hero_image":2492,"hero_image_position":"\"30% 70%\"","hero_title":"SOLID Principles in Delphi [1] - The Single Responsibility Principle","hero_content":"","hero_link":null,"hero_show_h1":false},"yoast_head":"\nPrinc\u00edpios SOLID em Delphi [1] - O Princ\u00edpio da Responsabilidade \u00danica - GDK Software<\/title>\n<meta name=\"description\" content=\"SOLID \u00e9 um conjunto de cinco princ\u00edpios de desenvolvimento de software que, ajuda desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica\" \/>\n<meta property=\"og:locale\" content=\"pt_BR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Princ\u00edpios SOLID em Delphi [1] - O Princ\u00edpio da Responsabilidade \u00danica\" \/>\n<meta property=\"og:description\" content=\"SOLID \u00e9 um conjunto de cinco princ\u00edpios de desenvolvimento de software que, ajuda desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo\" \/>\n<meta property=\"og:url\" content=\"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica\" \/>\n<meta property=\"og:site_name\" content=\"GDK Software\" \/>\n<meta property=\"article:modified_time\" content=\"2023-02-17T15:48:49+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. tempo de leitura\" \/>\n\t<meta name=\"twitter:data1\" content=\"5 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/base-de-conhecimento\\\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica\",\"url\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/base-de-conhecimento\\\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica\",\"name\":\"Princ\u00edpios SOLID em Delphi [1] - O Princ\u00edpio da Responsabilidade \u00danica - GDK Software\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br#website\"},\"datePublished\":\"2021-01-22T14:44:14+00:00\",\"dateModified\":\"2023-02-17T15:48:49+00:00\",\"description\":\"SOLID \u00e9 um conjunto de cinco princ\u00edpios de desenvolvimento de software que, ajuda desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/base-de-conhecimento\\\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica#breadcrumb\"},\"inLanguage\":\"pt-BR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/base-de-conhecimento\\\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/base-de-conhecimento\\\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Knowledgebase\",\"item\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/base-de-conhecimento\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Desenvolvimento de software\",\"item\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\\\/knowledgebase-category\\\/desenvolvimento-de-software\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Princ\u00edpios SOLID em Delphi [1] – O Princ\u00edpio da Responsabilidade \u00danica\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br#website\",\"url\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br\",\"name\":\"GDK Software\",\"description\":\"Zet de stip op je horizon\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/gdksoftware.com\\\/pt-br?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"pt-BR\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Princ\u00edpios SOLID em Delphi [1] - O Princ\u00edpio da Responsabilidade \u00danica - GDK Software","description":"SOLID \u00e9 um conjunto de cinco princ\u00edpios de desenvolvimento de software que, ajuda desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica","og_locale":"pt_BR","og_type":"article","og_title":"Princ\u00edpios SOLID em Delphi [1] - O Princ\u00edpio da Responsabilidade \u00danica","og_description":"SOLID \u00e9 um conjunto de cinco princ\u00edpios de desenvolvimento de software que, ajuda desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo","og_url":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica","og_site_name":"GDK Software","article_modified_time":"2023-02-17T15:48:49+00:00","twitter_card":"summary_large_image","twitter_misc":{"Est. tempo de leitura":"5 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica","url":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica","name":"Princ\u00edpios SOLID em Delphi [1] - O Princ\u00edpio da Responsabilidade \u00danica - GDK Software","isPartOf":{"@id":"https:\/\/gdksoftware.com\/pt-br#website"},"datePublished":"2021-01-22T14:44:14+00:00","dateModified":"2023-02-17T15:48:49+00:00","description":"SOLID \u00e9 um conjunto de cinco princ\u00edpios de desenvolvimento de software que, ajuda desenvolvedores a criar c\u00f3digo flex\u00edvel e limpo","breadcrumb":{"@id":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica#breadcrumb"},"inLanguage":"pt-BR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento\/principios-solid-em-delphi-o-principio-da-responsabilidade-unica#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/gdksoftware.com\/pt-br"},{"@type":"ListItem","position":2,"name":"Knowledgebase","item":"https:\/\/gdksoftware.com\/pt-br\/base-de-conhecimento"},{"@type":"ListItem","position":3,"name":"Desenvolvimento de software","item":"https:\/\/gdksoftware.com\/pt-br\/knowledgebase-category\/desenvolvimento-de-software"},{"@type":"ListItem","position":4,"name":"Princ\u00edpios SOLID em Delphi [1] – O Princ\u00edpio da Responsabilidade \u00danica"}]},{"@type":"WebSite","@id":"https:\/\/gdksoftware.com\/pt-br#website","url":"https:\/\/gdksoftware.com\/pt-br","name":"GDK Software","description":"Zet de stip op je horizon","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/gdksoftware.com\/pt-br?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"pt-BR"}]}},"_links":{"self":[{"href":"https:\/\/gdksoftware.com\/pt-br\/wp-json\/wp\/v2\/knowledge\/3953","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/gdksoftware.com\/pt-br\/wp-json\/wp\/v2\/knowledge"}],"about":[{"href":"https:\/\/gdksoftware.com\/pt-br\/wp-json\/wp\/v2\/types\/knowledge"}],"acf:post":[{"embeddable":true,"href":"https:\/\/gdksoftware.com\/pt-br\/wp-json\/wp\/v2\/team\/1398"}],"wp:attachment":[{"href":"https:\/\/gdksoftware.com\/pt-br\/wp-json\/wp\/v2\/media?parent=3953"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}