Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, graças às boas práticas e princípios exercitados nos cursos anteriores; mas você talvez não se sinta ainda confortável em lidar com cenários mais complexos, onde é difícil desenvolver software com código de qualidade com flexibilidade suficiente para facilitar a implementação de mudanças repentinas de requisitos. O objetivo deste curso é oferecer a você um aprofundamento em técnicas de programação orientadas a objetos pelo uso de padrões de projeto no contexto de desenvolvimento ágil. Os seguintes conceitos são apresentados neste curso: • Revisão de conceitos de orientação a objetos: abstração de dados, encapsulamento, herança e polimorfismo • Reúso por meio de herança: padrões Null Object, Template Method e Factory Method • Delegando comportamento com composição: padrões Strategy, Bridge, State e Observer • Composição recursiva: padrões Composite e Chain of Responsibility • Envolvendo objetos: padrões Proxy, Decorator e Adapter • Estratégias para criar objetos: padrões Static Fabric Methods, Singleton e Builder • Modularidade: padrão Dependency Injection Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar partes da aplicação Web final com o componente de gamificação enriquecido constantes do Trabalho de Conclusão da Especialização, aplicando onde apropriado alguns dos padrões apresentados neste curso durante a refatoração na prática TDD.
Hands-on: Padrão Strategy
Loading...
Do curso por Instituto Tecnológico de Aeronáutica
Desenvolvimento Ágil com Padrões de Projeto
46 classificações
Na lição
Semana 1
Olá, bem-vindo ao Curso 5 – Desenvolvimento Ágil com Padrões de Projeto! Estamos contentes que você esteja aqui para se exercitar com padrões de projeto. Neste módulo introdutório, você será apresentado inicialmente a uma revisão rápida de conceitos de orientação a objetos pertinentes a padrões de projeto; depois, a uma introdução a padrões de projeto, onde você aprenderá a usar o padrão Strategy. Ao final deste módulo você também terá aprendido uma forma alternativa a construtores para instanciar objetos, na forma do padrão Static Factory Methods.
Conheça os instrutores
Clovis FernandesProfessor Titular in Portuguese
Ciência da Computação
Eduardo GuerraProfessor Colaborador
[MÚSICA]
[MÚSICA] Olá a todos.
Meu nome é Eduardo Guerra,
estamos aqui mais hands on do Curso de Padrões de Projeto.
Nesse hands on, nesse primeiro hands on do nosso curso,
eu vou mostrar para vocês como fazer o padrão 'strategy',
usando esse mesmo exemplo do estacionamento que a gente viu nas aulas.
Bom, como a gente também é curso não só de Padrões de Projeto, mas também
de Desenvolvimento Ágil, a gente vai tentar usar o TDD para implementar.
Então, vou vir aqui, vou começar criando teste.
Vou criar aqui, teste cálculo,
vou botar aqui, 'tarifaEstacionamento'.
Okay?
Pediu para adicionar o JUnit aqui.
Certo?
Então, lembrando que aqui eu vou ter três tipos de tarifas que eu vou
fazer aqui nesse exemplo.
O primeiro vai ser a tarifa por hora, o segundo vai ser aquela tarifa
por hora no esquema que a gente tem muito shopping hoje,
que você tem valor fixo pelas primeiras três ou quatro horas e, depois,
você tem incremento por hora e, por fim, vamos ter o valor por diária.
Então, vamos lá.
Eu vou ter aqui..
Primeiro eu vou fazer o valor fixo por hora.
Então, vamos botar aqui, 'tarifaFixaPor Hora'.
Então, eu vou criar aqui uma classe.
Eu estou criando a classe, estou dizendo para o teste como eu quero que ela seja.
Então, 'tarifaEstacionamento',
t é igual a new,
'TarifaEstacionamento'.
E aqui eu vou passar, por exemplo, que eu tenho três horas.
E aqui eu vou passar uma classe que vai refletir qual
vai ser a forma do cálculo, ou seja, aqui eu estou forçando, de uma certa forma,
a minha classe a utilizar o 'strategy'.
De uma certa forma, eu estou direcionando, utilizando o teste,
o meu código para a utilização do 'strategy'.
Então, eu vou colocar aqui, new 'CálculoHora'.
Aí no caso aqui, eu posso já até colocar,
eu vou quebrar aqui para poder enxergar melhor.
Então, o meu cálculo hora vai ser aqui quatro reais a hora.
Aí aqui, eu vou mandar ele botar aqui,
vamos usar inteiro mesmo, para facilitar.
Então, int valor,
t ponto valor.
E aí eu vou fazer aqui assert equals,
que o meu valor vai ter que ser igual a 12.
São três horas, cada hora custa quatro, vai ser 12.
Bom, agora tenho que criar essas classes aqui, então eu já começo aqui criando
a classe tarifa estacionamento, lembrando que eu tenho que escolher
aqui para o source folder ser o código, não ser o código de teste.
Vou deixar aqui no pacote default mesmo.
Então, eu criei ali o tarifa estacionamento, vamos voltar lá no teste.
Criar agora o construtor.
Então, eu vou criar essa classe cálculo hora também no meu source.
Ele foi lá e criou.
Aí eu vou vir aqui e vou criar o construtor.
Só que eu não quero que ele utilize aqui direto esse cálculo hora,
eu quero que ele perceba aqui alguma coisa que seja uma interface.
Então, eu também vou deixar aqui genérico, já corrigi o meu construtor.
Certo?
Já vou vir aqui, ele vai reclamar.
Criar interface cálculo dentro do source, ok.
Vou salvar.
Ele ainda vai ter erro aqui.
Então, vamos ver aqui se ele...
Aqui, faça com que o cálculo hora implemente o cálculo, é o que eu quero.
Então, está lá.
[INAUDÍVEL] Ele falou, tarifa de estacionamento tem que ter método e valor.
Também vou clicar aqui e pedir para ele criar para mim.
Já está ali, certo?
Será que eu já consigo rodar o meu teste?
Ainda faltou o construtor do cálculo hora.
Ele criou ali.
Eu vou salvar.
Agora sim eu posso executar o 'run as'.
Opa, [INAUDÍVEL] consegui rodar.
Foi zero, não tenho nada ainda.
Então, vamos lá.
Aqui no tarifa do estacionamento vai ser
a quantidade de horas e o cálculo.
Então, eu vou criar aqui 'private int' 'qtd horas',
e aí 'private 'cálculo
cálculo', certo?
Então, eu vou vir aqui e vou guardar essas informações,
this ponto quantidade de horas é igual a quantidade de horas,
e this ponto cálculo recebe também o cálculo.
[EM BRANCO] Bom, aqui eu estou querendo
delegar para minha interface cálculo, que é o meu 'strategy',
o cálculo disso, no caso, o cálculo não sabe a quantidade de horas,
ele vai ter que receber isso como parâmetro.
Então, vou chamar aqui, cálculo ponto calcular tarifa
e vai passar a quantidade de horas ali.
Certo?
Então ele também não tem, vou clicar aqui.
Vou criar aqui o método 'calcularTarifa' na interface.
Sou obrigado a colocar public, mas eu gosto de deixar bem explícito.
E aqui a minha classe 'cálculoHora' também vai ter que ter isso daí.
Vai ter que ter o 'calcularTarifa'.
Então, eu vou implementar essa classe aqui agora.
Vou vir aqui, vou colocar private int,
'valorHora, certo?
Então aqui, 'valorHora'.
Então, deixa eu ver aqui o que eu vou fazer.
Vai ser, ele vai guardar ali, this ponto 'valorHora'
igual a 'valorHora'.
E aí na hora de calcular a tarifa, no caso desse cálculo aqui,
ele é simplesmente
o valor ali multiplicado pela quantidade de horas,
multiplicado pelo valor hora.
Salva aqui.
Agora eu vou rodar o meu teste, agora está fácil.
Podemos passar para o nosso próximo teste de unidade.
No caso aqui, acaba sendo teste meio de integração, que eu fui testando a classe
junto com a classe que está implementando o 'strategy', mas não tem problema.
Então, eu vou vir aqui,
tarifa com valor inicial depois fixa por hora.
Então, eu vou vir aqui,
eu vou até tirar isso aqui.
Eu vou criar uma nova classe, que vai ser o 'cálculoHora' ValorInicial'.
Então, no caso aqui por exemplo, vai ser cinco reais o valor inicial,
vão ser três horas o meu período
inicial e vai ser, por exemplo,
dois reais aqui o valor inicial.
Então, se eu tiver quatro horas, o valor tem que ser sete.
Ele vai cobrar cinco reais as três primeiras horas e mais
dois a hora seguinte.
Vamos botar até aqui, vamos botar cinco horas, aí o valor tem que ser nove.
Então, seria aqui, ele seria cinco quatro
três primeiras horas mais duas vezes dois, que é o que sobrou para dar cinco.
Então, seria nove.
Eu salvo aqui, ele não reconheceu esse cara,
ele vai vir aqui, eu vou criar,
note que ele já adicionou aqui a interface cálculo, que ele sabe que ali ele recebe.
Certo, mas mesmo assim ainda faltou aqui o construtor.
Então, criar o construtor,
então, eu vou colocar aqui,
esse daqui seria 'valorIncial',
'limiteHoras Inicial',
eu vou quebrar aqui para ficar mais fácil de enxergar, certo?
[INAUDÍVEL] e aqui por fim vai ser o
'valorHora Excedente'.
Então, vamos vir aqui,
criar [INAUDÍVEL] Eu vou dar uma de preguiçoso, eu vou dar control C aqui.
Então vamos lá: private aqui,
private aqui, ponto e vírgula lá,
outro private aqui, pronto.
Agora eu tenho que criar ali no construtor para ele poder receber esses valores aqui.
Então, 'valorInicial', this, não é?
'this ponto valorInicial' recebe o 'valorInicial',
'this ponto 'limiteHorasInicial' recebe
'limiteHorasInicial' e por fim o 'this ponto
valorHoraExcedente' vai receber o valor de hora excedente.
Então, criei aqui o construtor, vou agora, então,
fazer o cálculo aqui da tarifa.
Então, eu vou fazer aqui o seguinte: int valor,
eu vou fazer aqui igual
ao esse 'valorInicial' aqui.
Então, this ponto 'valorInicial', está OK?
Então, eu vou fazer o seguinte: valor mais igual
a a quantidade
de horas menos aquele limite
de horas inicial, isso aqui é menos.
Isso aqui vezes o valor da hora excedente.
Pronto.
Aí retorna aqui o valor.
Será que vai passar no teste?
Salva aqui e roda.
Passou.
Pronto.
Você pode estar falando: eu acho que isso aqui vai dar errado,
se a quantidade de horas for menor do que o limite.
Bom! Se a gente tem essa desconfiança,
o que que a gente faz?
A gente faz teste.
Então a 'tarifaComValorInicial' 'DentroDoLimite'.
Então, vamos lá!
Se a gente tiver, o limite é de três horas e se a gente tiver duas horas?
Ele tem que ter o valor cinco que é aquele valor do limite inicial.
Salva aqui, roda.
Opa!
Ele falhou, ele está três, não é?
Ele está subtraindo.
Então, não é isso o que a gente quer.
Então, a gente só pode fazer isso aqui,
se a quantidade de hora for
maior do que esse limite de horas inicial.
Será que agora vai dar certo?
Tem que dar os dois testes certo.
Passou agora.
Que bom!
Bom!
Vamos lá então criar o nosso já temos três testes aqui,
vai ser o nosso 'tarifaDiaria'.
Então, no lugar de receber aqui
vai ser new 'CalculoDiaria'.
Eu já vou colocar exemplo aqui, por exemplo,
50 horas que daria ali três diárias.
Então, aqui o 'CalculoDiaria',
simplesmente eu vou colocar o valor da diária que, por exemplo, vai ser 20.
Então, para 50 ali o valor tem que ser 60.
Eu salvo aqui, tenho que fazer esses testes passarem.
Então, criar a classe aqui, que ele já cria para mim,
começa a criar aqui também o construtor.
Então aqui vai ser o 'valorDiaria',
eu vou criar aqui o atributo para ele gravar aqui,
'valorDiaria' aí
eu tenho que guardar aqui,
ponto 'valorDiaria' igual 'valorDiaria'.
Aí agora eu vou calcular a minha tarifa aqui,
a cada 24 horas, eu tenho que calcular uma diária.
Então, eu vou fazer aqui: ele
vai retornar o valor da diária vezes
a quantidade de horas dividido
por 24, certo?
Será que vai dar certo isso aqui?
Vamos rodar.
Deu errado.
Está dando 20 a menos.
Então, o que que eu posso fazer aqui?
Eu acho que se eu colocar assim, ele vira double,
aí eu posso fazer assim ponto ceil, não é?
Aí ele vai pegar aqui o valor de cima
e aqui eu tenho que fazer
eu vou pegar o int, não é?
[INAUDÍVEL] [INAUDÍVEL] aqui, rodo.
Deu certo.
Eu vou fazer outro teste aqui só para garantir aqui.
Eu fazer teste aqui.
É o seguinte: eu tenho aqui, sei lá, dez horas, ele tem que dar uma diária só.
Será que vai dar certo?
Então, vamos ver, 'tarifaDiariaMenorQueUmDia'.
Eu vou ver o que que está dando aqui.
Rodo aqui.
opa!
Danou-se!
Está valendo aqui.
Então, eu fui fazendo, note que eu direcionei aqui o
meu designer aqui para usar aqui para o 'strategy', não é?
O caso aqui é exemplo simples,
só para a gente aprender como se faz essa delegação através do 'strategy'.
Note que, se eu tivesse que fazer cálculo diferente, era só colocar aqui,
por exemplo, se eu tivesse nessa tarifa estacionamento aqui algum
adicional de imposto, alguma coisa que seria sempre,
talvez seja uma coisa que eu não precisasse alterar,
essa classe 'TarifaEstacionamento' poderia ser pouco mais complexa.
Aqui foi simples porque é exemplo didático, mas a gente viu que
aqui se isolou utilizando o padrão 'strategy' como seria
o cálculo do valor ali da tarifa do estacionamento.
Então, é isso.
Espero que, a partir do exemplo, o padrão 'strategy' tenha ficado mais claro.
Muito obrigado por assistir a aula.
[MÚSICA] [MÚSICA]
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
