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 Observer
Loading...
來自 Instituto Tecnológico de Aeronáutica 的課程
Desenvolvimento Ágil com Padrões de Projeto
54 個評分
從本節課中
Semana 2
Olá, bem-vindo ao Curso 5 – Desenvolvimento Ágil com Padrões de Projeto! Neste módulo você aprenderá a identificar quatro padrões em que se utiliza a herança; depois, três padrões em que se utiliza a composição.
與講師見面
Clovis FernandesProfessor Titular in Portuguese
Ciência da Computação
Eduardo GuerraProfessor Colaborador
[MÚSICA]
[MÚSICA] Olá a todos!
Meu nome é Eduardo Guerra e estamos aqui no curso de Padrões,
e hoje vamos mostrar o padrão "Observer" Bom, a ideia,
enquanto eu vou explicando eu já vou criando aqui o primeiro
teste de unidade, a nossa classe alvo aqui de desvio
padrão seria uma classe que a gente vai chamar de "Quebrador String".
Mas a gente vai começar como sempre aqui pelo teste,
Teste "Quebrador String",
Ele vai pedir para eu colocar o "JUnit" ali,ok.
E então, é uma classe que simplesmente pega
uma frase e quebra as palavras.
Vamos chamar ao invés de "Quebrador String",
vamos chamar de "Quebrador Palavras", acho que é melhor.
Os nomes são importantes.
Certo?
Então, "Quebrador de Palavras" Então vamos criar.
A ideia é ser uma classe que ela quebra uma frase palavras,
e aí depois a gente quer que esse quebrador, ele possa contar uma frase
palavras, quantas palavras têm por diferentes critérios,
por exemplo, quantas palavras começam com letra maiúscula,
quantas palavras têm uma quantidade par de caracteres,
então ele poderia, quando ele quebra,
ele vai ter essa funcionalidade de estar contando a palavra
por esses diferentes critérios.
Então, eu vou vir aqui, eu vou criar uma "String", frase,
vou botar aqui "O rato
roeu a roupa do rei".
Certo?
E aí eu vou vir aqui,
vou chamar aqui o meu,
vou criar o meu "Quebrador Palavras",
"Quebrador Palavras" Certo?
Opa!
Igual a mil.
"Quebrador Palavras".
Se você falar: "Que classe é essa aí que eu nunca ouvi falar?" Então não
existe ainda, né?!
É mas a gente está fazendo o TDD aqui.
Então, eu vou vir aqui,
botei aqui "Palavra" igual
a "Quebrador" ponto quebrar.
Então ali eu vou ter que ter como contar: Uma,
duas, três, quatro, cinco, seis, sete.
Então eu vou fazer aqui "AssertEqual".
"Sete" igual à "Palavras" ponto "Length".
Ok.
Vamos salvar aqui, primeiro eu tenho que criar esse "Quebrador Palavras".
Cria a classe, vou criar lá no meu "Source", vou criar aqui o meu teste.
Criou ali o meu "Quebrador de Palavras".
Bom, tem que criar agora esse "Quebrar" aqui.
Opa! Faltou passar a frase aqui,
vamos apagar isto.
Agora sim.
Salvo aqui.
Eu vou criar o método "Quebrar",né?!
A princípio,
vou dar simplesmente "Split" aqui.
Frase ponto "Split", por espaço e ele vai quebrar.
Lembrando que nosso exemplo aqui é para ilustrar mesmo o uso do padrão.
Criou ali!
Vamos rodar aqui nosso teste.
Opa!
"Run As" Ok.
Bom, como é que eu quero aqui agora?
Eu quero, por exemplo,
poder chegar aqui no meu, vou botar aqui,
contador simples, certo?!
Eu vou vir aqui no meu "Quebrador" e vou fazer o seguinte.
"Quebrador" ponto,
adiciona contador.
E aí eu vou vir aqui e vou
chamar aqui de Simples, certo?
E vou dar "new" contador
simples, ok?
Então eu adiciono ali cara, aquele cara ali vai ser "Observer",
ele vai observar as palavras e vai contar aquelas que ele achar adequedas.
Então eu vou vir aqui, vou ali no meu "Quebrador", Opa!
"Quebrador".
E vou vir aqui, vou chamar o "Get Contagem".
Qual contagem que eu quero?
Aquela simples ali.
E aí ele tem que me retornar sete, é isso que eu quero que ele faça.
Então eu vou salvar aqui, lógico não existe nada disso ainda,né?!
Eu vou criar aqui, "Contador Simples",
vou criar lá no "Source", certo?!
Eu já vou dizer
que ele vai ter que implementar "Contador Palavras".
Opa!
Aí sim.
Esse também não existe, eu vou criar também.
Tudo bem.
Para quê que eu fiz isso?
Para poder já acertar aqui a interface.
Tem que criar agora esse "Adiciona Contador", vamos criar esse método aqui,
só que ao invés dele receber, ai eu vou chamar aqui "nome do
contador", e ele vai receber "Contador Palavras".
Muito bem.
Ele está adicionando aquele tipo ali de contador,
e aqui no "Get Contagem", está aqui o método,
ele vai subir aqui o nome e vai retornar inteiro.
No caso aqui eu vou retornar zero só para ele não dar pau.
Ok, muito bom!
Perfeito!
Então agora, eu já consigo rodar o teste, né?!
Certo?
Ele vai dar errado, porque ele está retornando o zero ali.
E vamos implementar aqui o nosso "Quebrador de Palavras",
a primeira coisa, então, no "Observer".
Aqui é como se fosse aquele método tradicional "Observer".
Aqui é pouquinho diferente porque eu vou criar mapa,
porque eu estou criando pelo nome.
Então, eu estou criando "Map" de
"String" por "Contador Palavras", né?!
É, contadores,
aqui eu vou criar "new" "Hashmap" aqui.
Opa!
Bom demais!
Então quando eu vi aqui, vou mandar adicionar, certo?
Eu preciso é...
quando eu mandar adicionar, eu preciso adicionar ali nos meus contadores,né!?
Contadores, ponto, "Put", o nome e o contador.
Legal, legal!
Bom, agora, eu tenho que pegar contagens.
Bom, quem vai saber essa contagem?
O contador,né?!
Então eu vou vir aqui, vou pegar ali o contadores,
ponto, "get", o nome,
ponto, é...
"Get Contagem", uma só contagem.
Esse método não existe ainda.
E aquela coisa também, para eu poder contar, eu preciso, antes,
passar as coisas para ele,né?!
Então eu vou vir aqui, nesse "Frase" ponto "Split ali,
vou extrair aqui uma variável local,
"Palavras", muito bem!
Eu preciso mandar os computadores contarem.
Então eu vou fazer 'for' aqui.
Para cada 'String' nas 'palavras',
opa, para cada 'palavra' na 'palavras',
[SEM_ÁUDIO] eu vou mandar os computadores contarem.
Eu vou vir aqui 'Contador Palavras'
e nos 'Contadores' "ponto" os valores.
Então eu vou vir ali olha, 'c.contar',
aquela 'palavra'.
Certo?!
Bom, se eu olhar aqui, o meu 'contador.palavras' não tem nenhum desses
dois métodos, então a gente cria aqui, manda adicionar lá.
Criar método, muito bem, salva.
E eu preciso que meu contador simples tenha esses métodos.
Então eu vou criar aqui 'Private' 'int qtd',
a quantidade de palavras.
Quando eu mandar contar, no caso aqui ele vai contar todas.
Então ele vai somar, 'qtd.++', no caso.
E a minha contagem vai retornar aquela quantidade ali.
Rodou, olha, passou no teste.
Agora, você fala assim: "Nossa, mas isso daí foi bem simples,
você fez praticamente o que tinha ali".
Mas eu criei toda essa estrutura.
Olha, você nem precisa desse palavras aqui mais.
Eu criei toda essa estrutura para poder criar os próximos contadores.
Então, olha,
eu vou vir aqui olha, vou adicionar o meu contador aqui.
'MAIÚSCULA'.
E vou adicionar aqui o 'Contador' 'Maiúscula'.
Bem, então
aqui olha, vamos ver qual vai ser o meu teste.
O rato e o rei eu vou colocar com o R maiúsculo.
E aí a minha contagem aqui vai ser dois.
Olha como eu já tenho toda a minha estrutura agora
do meu observer aqui dentro do quebrador.
Então note que aqui cada contador de palavra
é como se estivesse observando cada palavra que ele quebrou ali.
Então quando eu mando ele contar, na verdade eu estou observando.
Às vezes a gente usa o padrão.
Não tem que usar o nome daquelas que a gente usa ali.
E aqui olha, no meu observer, cada está me dando uma resposta diferente.
Então eu vou vir aqui.
Cliquei.
Vou criar a minha classe 'Contador Maiúscula' aqui dentro do Source.
Olha lá, ele já sabe que é 'Contador Palavras'.
Bom, aqui eu preciso implementar ele agora.
Então eu vou verificar aqui se a palavra começa com maiúscula.
Então vamos lá: " 'if' palavra
'ponto get'
'charAt' na posição zero,
que é a primeira, eu acho que tem 'character'
ponto 'isUppercase',
'isUpperCase' estou pegando o zero e vendo se é 'Upper Case'.
Se for eu vou somar aqui, olha: " 'qtd++'" Vamos criar outro aqui.
Eu vou...
'contador'
'LetrasPares'...
Então, eu vou criar aqui 'pares',
e vou criar aqui o meu 'contador pares'.
[SEM_ÁUDIO] Ele
vai contar quantas palavras com quantidade de letras pares que tem.
No caso aqui ele tem o rato, uma, duas, e três.
Então vamos lá.
Mesma coisa.
Olha como é fácil adicionar vários contadores aqui depois que eu
criei aquela estrutura do observer.
Então vamos criar
aqui dentro do source.
É a mesma coisa.
A gente fixa nossa variável, para contar aqui.
Eu vou ver, olha, no caso eu vou pegar aqui.
Se a 'palavra' 'ponto length'.
A gente pega o resto por tempo.
Então se o resto da divisão por dois for
igual a zero, ou seja, é uma forma de ver se ela é par.
'qtd++' E aí ele retorna ali a quantidade.
[SEM_ÁUDIO] Vamos
rodar aqui o nosso teste.
Opa!
Olha lá, o quatro passando ali.
Vamos só para desencargo de consciência,
vamos fazer o teste com todos ao mesmo tempo,
para ver se ele está contando todo mundo ali.
Colocar aqui, 'Contador Integrado'.
[SEM_ÁUDIO] Eu vou usar essa frase mesmo, mas eu vou estar adicionando todos ali.
Vou adicionar aqui maiúscula.
Vou adicionar ali o simples.
[SEM_ÁUDIO] Será que
funciona com vários contadores ao mesmo tempo?
É o que a gente vai ver agora, né?!
Coloco aqui maiúscula, coloco aqui simples.
Eu poderia até usar uma outra frase, mas vamos rodar com essa aqui mesmo.
Rodou.
Olha, funcionou.
Então a gente viu que a gente usou aqui o conceito do observer,
tendo que a gente teria a adição dos observadores da diferença.
Lembra que eu comentei para vocês que o padrão nem sempre é exatamente
da mesma forma.
No caso aqui, eu criei o meu observer
pouco diferente para se adaptar a minhas necessidades.
No caso aqui, os contadores observam,
mas eles também vão contar ali as palavras e vão gerar resultado que é o que
eu vou pegar aqui nesse guia de contagem a partir do nome que eu dei para ele.
Certo?
Então eu espero que tenha ficado claro como o observer pode
dar essa flexibilidade para a gente.
Muito obrigado.
Continue assistindo o curso.
[MÚSICA] [MÚSICA]
