[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]
