Tá acabando!

Compre agora com desconto
Corra enquanto há tempo!

dias

:

horas

:

minutos

:

segundos

Primeiras aulas do curso Design Patterns em Java I: Introdução às boas práticas de programação

Design Patterns em Java I: Introdução às boas práticas de programação

Strategy - Apresentação

Olá pessoal. Seja bem-vindo ao treinamento de Design Patterns com Java. O meu nome é Rodrigo Ferreira e eu vou ser o instrutor que vai acompanhar vocês durante esse treinamento. Então a ideia desse treinamento é aprendermos alguns padrões de projeto. E aí para começar aquela discussão, o que é um padrão de projeto? Então eu resumi de uma maneira bem simples o que seria um padrão de projeto.

Talvez você já tenha se esbarrado com esse termo, já tenha utilizado esses padrões em algum projeto pessoal ou da sua empresa, enfim. Então o padrão de projeto nada mais é do que uma solução comum para um problema que é recorrente, um problema que aparece com bastante frequência quando você trabalha com programação orientada a objetos.

Então quando você trabalha com esse paradigma da orientação a objetos é comum você se esbarrar em alguns problemas conforme você vai desenvolvendo a sua aplicação. E esses problemas vão se repetindo em diversos projetos, em diversos trechos do seu código.

Em vez de você sempre ter que pensar em uma nova solução para resolver, para lidar com aquela estrutura do design do código, você pode utilizar um padrão que já foi pensado para aquele determinado tipo de problema. Então é aquela famosa frase de nós não reinventarmos a roda.

Já tem aquela solução para aquela situação daquele design de código, para aquele problema específico é recomendado utilizar o padrão X. Então você vai utilizar o padrão X para não reinventar a roda para não ficar quebrando a cabeça e pensando em uma solução que dificilmente outras pessoas vão conhecer.

Então essa que é a ideia dos padrões de projeto, criar uma solução comum para um problema recorrente da orientação a objetos. E esse termo ficou popular com a escrita desse livro que foi lançado em 1994. Então é um negócio bem antigo, já tem aí décadas de utilização desses termos e desses padrões. E é esse livro, Design Patterns escrito por esses quatro autores que ficaram conhecidos como "Gang of Four".

Então esse livro ficou conhecido como o livro dos padrões do GOF, "Gang of Four", a gangue dos quatro que seriam esses quatro autores. Então esse livro foi escrito para focar especificamente em alguns dos principais padrões de projetos que eram comuns para esses principais problemas até então conhecidos na construção de softwares utilizando a orientação a objetos, o paradigma da orientação a objetos.

Então esse livro foi o livro referência para os padrões de projetos e nós vamos focar nesse livro, nos padrões de escritos nesse livro. E aí esse livro mostra para nós, ele traz 23 padrões que os autores identificaram que eram bastante recorrentes na comunidade de desenvolvimento de software orientado a objetos e esses padrões eram divididos em três categorias, tinha os padrões criacionais cujo foco é na construção, na criação de objetos.

Então você tinha que modelar, fazer o designer de uma classe e aí eu preciso criar um determinado objeto de um tipo e aí existem alguns padrões focados justamente nessa parte de criação de objetos. Tem outros padrões que são focados mais na parte de estrutura e composição entre esses objetos e essas classes, como que elas vão se relacionar em si. E aí são os padrões estruturais.

E tem também os padrões focados mais na parte de comportamento, na parte dos métodos de estado e interação entre os objetos, são os padrões comportamentais. Então dentro dessas três categorias existem alguns padrões. E aqui nesse curso nós vamos focar apenas na categoria de comportamental. Então vamos estudar alguns dos padrões comportamentais. Claro, não vamos estudar todos os padrões, não é esse o objetivo.

O objetivo é estudar os principais e mais comuns padrões dessa categoria que são mais recorrentes do nosso dia a dia de desenvolvimento de software. Nós vamos estudar o Strategy, o Chain of Responsibility, Template Method, State, Command e Observer.

São seis padrões bastante comuns, bastante recorrentes no dia a dia quando estamos trabalhando com desenvolvimento de software orientado a objetos. E esses seis estão na categoria comportamentais. Por agora você não precisa se preocupar em o que significa cada um desses padrões, como que eles funcionam porque durante o treinamento eu vou guiar vocês mostrando alguns exemplos de como que vai funcionar cada um desses padrões.

Então espero que vocês gostem e aproveitem esse treinamento e possam utilizar esses padrões no seu dia a dia sempre que fizer sentido e que for o caso. Então eu vejo vocês na próxima aula onde vamos estudar o primeiro padrão que é o Strategy. Um abraço e até lá.

Strategy - Criando o projeto

Olá pessoal. Continuando o nosso treinamento de Design Patters. O vídeo de hoje eu vou criar o projeto aqui com vocês, o projeto que vamos trabalhar durante o treinamento e eu vou utilizar como ambiente o Eclipse como o IDE, mas isso daí não influencia em nada. Você pode usar a sua IDE de sua preferência. E a ideia é criarmos uma aplicação Java tradicional.

Então como o foco do curso é em código, design de código e padrões de projeto, nós não vamos focar na parte Web, nem banco de dados, infraestrutura, Frameworks e nem nada do gênero. Vamos focar exclusivamente na parte de código e de design de código. Então vai ser uma aplicação Java tradicional.

Então aqui no Eclipse eu vou escolher essa opção, "Create a project", "Java Project", o nome do projeto vou chamar de "loja". A princípio eu estou utilizando a versão 11 do Java. Você pode usar qualquer versão a partir da versão 8. Então não precisa ser necessariamente a versão 11. E aí "Finish" e ele vai pedir para criar um module info. Eu não vou criar. Isso não vai ser utilizado.

Não vou trocar a perspectiva. E está aqui o nosso projeto. A pasta "loja", o "src". Então aqui dentro do "src" eu vou criar uma classe. E uma das classes principais aqui do projeto que vamos ter do nosso treinamento é uma classe chamada “Orcamento”.

Então essa aplicação vai ser parecida com uma loja, um e-commerce onde vamos ter uma parte de orçamento de pedidos, de impostos, de descontos e coisas relacionadas com isso. Então vou criar aqui a classe principal. Vai se chamar "Orcamento" e eu vou trocar o pacote para ser "br.com.alura.loja.orcamento". Então esse vai ser o pacote onde vai ficar essa nossa primeira classe.

E aí beleza, só para começarmos e ter alguma coisa aqui no nosso projeto. E aí aqui dentro da classe "Orcamento" a princípio a primeira informação que vamos precisar é o valor do orçamento. Então todo orçamento precisa ter um valor. Então vou criar aqui um atributo private BigDecimal valor. Então como é valor monetário geralmente utilizamos BigDecimal. Vou importar o BigDecimal.

E mais uma coisa que eu vou fazer é gerar o método getter, "getValor" e vou gerar também o construtor para quando essa classe for instanciada nós já passarmos como parâmetro o valor, esse "BigDecimal". Então está aí criado e essa vai ser a primeira classe e uma das principais classes que vamos trabalhar aqui no nosso projeto, a classe "Orcamento" e por enquanto ela só recebe um valor.

Então essa é a infraestrutura e esse é o projeto inicial onde vamos trabalhar durante o nosso treinamento. Então vamos a partir dessa classe, desse projeto ir passando por alguns problemas, implementando algumas funcionalidades e vendo como utilizar os padrões de projeto. Então no próximo vídeo vamos implementar a primeira funcionalidade e aí vai cair em um problema onde vamos utilizar o nosso primeiro padrão. Então eu vocês no próximo vídeo. Um abraço e até lá.

Strategy - Calculando impostos

Olá pessoal. Continuando aqui. Agora que já temos o nosso projeto, a nossa classe de orçamento, chegou a primeira demanda. Nós precisamos implementar uma funcionalidade para fazer o cálculo de impostos. Então dado um orçamento, eu preciso saber qual que é o valor do imposto a ser pago por ele. Então para implementar essa funcionalidade, vamos criar uma nova classe.

Então vou dar um "Control + N > Class", só vou aí eu vou colocar ela em um pacote chamado "imposto" e o nome dessa classe vai ser "CalculadoraDeImpostos". Então esse que é o objetivo dessa classe, fazer o cálculo de impostos. E aí aqui dentro eu vou ter um método public BigDecimal calcular. Então a ideia é, esse método vai receber como parâmetro o orçamento, vou chamar de orçamento o atributo e ele devolve um BigDecimal que é o valor do imposto desse orçamento que foi passado como parâmetro.

E aqui dentro nós implementamos qual é a regra de negócio. Então aí vai depender do requisito de negócio, qual é o valor do imposto e tudo mais. Vamos imaginar que o imposto é 10% do valor do orçamento. Então aqui colocaríamos esse código return orcamento.getValor., aí é um BigDecimal, então .multiply(new BigDecimal, vou multiplicar por 0.1. E aí com isso eu vou ter o valor que é equivalente a 10% do valor do orçamento. Então pronto, foi implementada a funcionalidade.

Porém aí vem aquela questão, 10% é o valor do imposto, mas qual imposto? Nós temos vários tipos de impostos. Então aqui no caso vamos imaginar que é o ICMS. Então o ICMS tem essa alíquota de 10%. E se eu tiver outros tipos de impostos? Então essa minha calculadora está muito engessada. Ela só sabe calcular o valor de um único imposto que é o ICMS.

Então eu preciso deixar o código um pouco mais flexível para eu consegui calcular o valor do imposto independente de qual é o tipo do imposto. Então como que nós podemos fazer esse ajuste? Então como esse cálculo vai depender do tipo do imposto, além do orçamento eu preciso receber um outro parâmetro. Poderia ser uma string, “String TipoImposto".

Poderia receber essa string e aqui dentro eu fazer essa lógica, fazer um if, um switch baseado no tipo de imposto e eu devolvo o cálculo apropriado. Só que aí string é meio ruim porque eu não tenho controle. Eu posso passar qualquer tipo de string. Então vamos melhorar isso aqui. Vamos transformar isso em um enum que é aquela classe do Java que representa o conjunto de constantes como se fosse uma classe. Então vou criar aqui um enum chamado "TipoImposto".

Aí ele vai reclamar porque não existe essa classe. Vou dar um "Control + 1", vou escolher a opção "Create enum", vou jogar no próprio pacote de imposto e aqui dentro eu coloco os constantes "ICMS" e vamos imaginar que por enquanto nós temos também o "ISS". Tem esses dois tipos de impostos. Agora a minha calculadora, o método calcular recebe o orçamento e o tipo de imposto.

E agora eu preciso fazer um if else, um switch case, alguma coisa assim porque o return vai ser baseado nesse tipo de imposto. Então vou fazer um switch case. Então switch TipoImposto que foi passado como parâmetro caso seja "ICMS" ele vai retornar aquela linha que ficou ali embaixo. Eu vou dar um "Control + X" nela e jogar para cá. E aí como já está fazendo um return não precisa do break aqui. Eu vou fazer um outro "case" aqui. Caso "case" seja "ICMS" o tipo de imposto, aí ele vai retornar.

Vamos considerar que o "ISS", o imposto dele é 6% do valor do orçamento. Então aqui vou colocar return orcamento getValor.multiply (BigDecimal("0.06") que aí seria 6%. E se não for nenhum desses casos, se não cair em nenhum e nem em outro, vou colocar um default aqui e aí a princípio return BigDecimal. Nós vamos precisar para compilar, "BigDecimal.ZERO".

Então se não for nem "ICMS" e nem "ISS" eu vou retornar por enquanto zero. Então pronto, está implementado aqui a nossa funcionalidade. Será que funciona? Como é que eu consigo testar? Então vamos lá. Para fazer os testes eu vou criar aqui no pacote raiz da aplicação uma classe com o método main do Java. Então vou criar uma classe "TestesImpostos" e vou marcar aqui para ele já gerar com o método main. E aqui vamos fazer um teste.

Vamos criar um orçamento, Orcamento orcamento = new Orcamento e aí quando instancia o orçamento nós precisamos passar o BigDecimal". Então "new BigDecimal, vou passar aqui um orçamento com valor de 100 reais, por exemplo. Então vou passar "100". Já instanciei o orçamento e agora preciso instanciar a calculadora. Então CalculadoraDeImpostos calculadora, vou deixar o nome só calculadora, new CalculadoraDeImpostos e aí agora eu quero imprimir.

Vou dar um System.out(calculadora.calcular) passando esse "orcamento" e o imposto eu vou passar TipoImposto.ICMS. Então pela nossa lógica ele deveria imprimir 10 reais que é 10% sobre o valor de 100 que é o valor do orçamento. Vamos rodar e ver o que vai acontecer. Dez reais. E se eu trocar agora o tipo de imposto para "ISS", vou trocar a constante para "ISS" e rodar, 6 reais, 6%.

Então beleza, está funcionando. Então a nossa calculadora de impostos está funcionando corretamente e ela está um pouco flexível. Ela funciona tanto para ICMS quanto para ISS e ela está, digamos assim, extensível. Se futuramente surgir um novo tipo de imposto, é só eu adicionar mais um "case" aqui.

Porém, embora esteja funcionando e ela permita eu adicionar novos impostos, o jeito que está o código aqui não é o melhor jeito possível porque toda vez que surgir um novo imposto ou mudar a regra ou a alíquota de um determinado imposto, eu sempre vou ter que vir aqui e mexer na classe "CalculadoraDeImpostos". Então essa classe sempre vai crescer sem parar. Se tiverem 20, 30 impostos, aqui vai ter 20, 30 cases. Então essa é uma classe que não para de crescer nunca.

Ela fica cheia de if e else, cheio de switch case e começa a ficar poluído, começa a ficar difícil de dar manutenção nessa classe. Então esse é um tipo de problema que é comum nos projetos, nós termos esse tipo de código. Eu tenho uma determinada regra de negócio, um algoritmo, um cálculo, uma validação. Só que essa regra varia de acordo com um parâmetro que no nosso caso é o tipo de imposto.

Então acabamos tendo esse tipo de código. Se eu tenho uma regra é a mesma regra que é o cálculo de imposto, só que ela varia de acordo com uma determinada informação que no caso é o tipo de imposto ou você acaba escrevendo esse tipo de código com um monte de if e else e um monte de switch case para saber se aquela informação for de um tipo, faz o cálculo desse jeito.

Se for desse outro tipo, faz o cálculo desse outro jeito. E aí esse é um problema comum recorrente. E nós já sabemos, sempre que tivermos um problema comum recorrente, o ideal é utilizar um padrão de projeto para deixar o nosso código mais flexível, mais simples de manter e de evoluir. Então no próximo vídeo vamos discutir em como resolver esse problema e qual é o padrão apropriado para atacar esse tipo de problema. Então vejo vocês no próximo vídeo. Um abraço e até lá.

Sobre o curso Design Patterns em Java I: Introdução às boas práticas de programação

O curso Design Patterns em Java I: Introdução às boas práticas de programação possui 127 minutos de vídeos, em um total de 49 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Aprenda Java acessando integralmente esse e outros cursos, comece hoje!

Plus

Desconto 25%
  • Acesso a TODOS os cursos da plataforma

    Mais de 1200 cursos completamente atualizados, com novos lançamentos todas as semanas, em Programação, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.

  • Alura Challenges

    Desafios temáticos para você turbinar seu portfólio. Você aprende na prática, com exercícios e projetos que simulam o dia a dia profissional.

  • Alura Cases

    Webséries exclusivas com discussões avançadas sobre arquitetura de sistemas com profissionais de grandes corporações e startups.

  • Certificado

    Emitimos certificados para atestar que você finalizou nossos cursos e formações.

  • Alura Língua (incluindo curso Inglês para Devs)

    Estude a língua inglesa com um curso 100% focado em tecnologia e expanda seus horizontes profissionais.

12X
R$85 R$63,75
à vista R$1.020 R$765
Matricule-se

Pro

Desconto 25%
  • Acesso a TODOS os cursos da plataforma

    Mais de 1200 cursos completamente atualizados, com novos lançamentos todas as semanas, em Programação, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.

  • Alura Challenges

    Desafios temáticos para você turbinar seu portfólio. Você aprende na prática, com exercícios e projetos que simulam o dia a dia profissional.

  • Alura Cases

    Webséries exclusivas com discussões avançadas sobre arquitetura de sistemas com profissionais de grandes corporações e startups.

  • Certificado

    Emitimos certificados para atestar que você finalizou nossos cursos e formações.

  • Alura Língua (incluindo curso Inglês para Devs)

    Estude a língua inglesa com um curso 100% focado em tecnologia e expanda seus horizontes profissionais.

12X
R$120 R$90
à vista R$1.440 R$1.080
Matricule-se
Conheça os Planos para Empresas

Acesso completo
durante 1 ano

Estude 24h/dia
onde e quando quiser

Novos cursos
todas as semanas