Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, com método e organização graças às boas práticas e princípios exercitados no curso anterior; mas você talvez não se sinta ainda confortável em projetar programas usando técnicas ágeis, como o desenvolvimento guiado por testes (TDD). O objetivo deste curso é expor você aos princípios e práticas de desenvolvimento guiado por testes, tanto para modelar quanto para desenvolver aplicações e componentes de software, sem abandonar os conceitos e princípios de orientação a objetos aprendidos no curso anterior. De fato, pregamos que tais conceitos e princípios fortalecem o emprego do TDD no desenvolvimento ágil de software com mais qualidade. Este curso terá um grande foco em atividades hands-on, permitindo a você captar todos os aspectos práticos da técnica e facilitar a sua aplicação quando estiver projetando e desenvolvendo software de maneira ágil nos próximos cursos. Os conceitos de desenvolvimento de software com Java apresentados neste curso incluem o seguinte: revisão de testes de unidade; automação de testes; desenvolvimento guiado por testes; ciclo do TDD; refatoração de código de produção; ciclo de refatoração; uso de objetos stubs e mocks; boas práticas no TDD; modelagem de software por meio do TDD. Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar, agora usando o TDD, versões modificadas e estendidas do componente de gamificação constante do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.
Hands-on - Refatorando a Video Locadora - Parte 5
Loading...
Do curso por Instituto Tecnológico de Aeronáutica
TDD – Desenvolvimento de Software Guiado por Testes
330 classificações
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
Instituto Tecnológico de Aeronáutica
330 classificações
Na lição
Semana 4
Olá! Bem-vindo à Semana 4 do curso sobre TDD! Nesta semana você aprofundará seu contato teórico e prático com técnicas de refatoração. Ao final desta semana, você será capaz de identificar alguns dos principais tipos de mau cheiro e aplicar técnicas de refatoração apropriadas para remoção segura desses maus cheiros.
Conheça os instrutores
Clovis FernandesProfessor Titular in Portuguese
Ciência da Computação
Eduardo GuerraProfessor Colaborador
[MÚSICA] [MÚSICA] Quem diria?
Quem diria!
Estamos aqui na última parte da nossa sequência de vídeos de refatoração.
Estamos refatorando o mesmo código e a cada vídeo ele muda mais de cara, está?
A gente passou monte de coisas para as classes Movie, Rental, agora a gente
criou subclasses, substituiu aqui monte de if, monte de condicional por polimorfismo.
Pessoal, não leva a mal não, mas eu acho isso muito bonito.
Para mim, isso aqui é arte.
Está certo?
Vamos voltar, não é?
Agora que a gente já poliu aqui as nossas classes Movie e Rental não é?
Criamos aqui as subclasses Regular,
NewRelease, a Childrens não é?
Vamos voltar aqui na nossa classe Customer.
Nossa Senhora, argh!
Tinha desacostumado a ver esse código feioso aí está?
Eu vou é, vamos refatorar.
Uma coisa que eu não estou gostando aqui é porque ele faz esse
cálculo da quantidade, da soma dos amounts,
da soma dos frequentRenterPoints misturado com o statement.
Está? Isso eu não acho legal.
Então o que é que eu vou fazer aqui?
Eu vou é, criar esses métodos está?
E como está tudo muito misturado fica até difícil de extrair isso
usando o Eclipse está?
Então eu vou criar aqui método public é, double é,
que eu vou chamar de getTotalAmount.
Nesse caso faz sentido esse método estar aqui,
porque eu estou calculando o total do cliente.
Então é uma coisa relacionada ao cliente.
Está?
Então eu vou vir aqui, vou pegar esse,
esse pedação aqui onde esse
cálculo está todo misturado e vou jogar aqui dentro está?
E aí eu vou começar a tirar coisas que não são importantes para mim,
como isso, isso, aqui ele está
pegando o getAmount, é e aqui eu posso tirar isso aqui.
ali ele está somando.
E no final aqui eu posso dar return é,
esse totalAmount.
Dá para dar uma melhorada aqui não é?
Eu não precisaria de criar esse thisAmount,
é até uma refatoração que eu gosto bastante, que é o inline não é?
Por exemplo, se eu vier aqui e der inline, ele vai substituir o, pela implementação.
Olha, ele fez isso aqui sozinho, está vendo?
O Eclipse, às vezes, é esperto, às vezes ele é esperto está?
Então aqui eu já posso tirar as coisas referentes ao cálculo do total, não é?
Então aqui eu posso excluir, eu posso excluir isso daqui.
E aqui, ao invés do totalAmount,
eu dou getTotalAmount.
Certo.
Aí aqui, se eu for olhar, ele também pega esse thisAmount.
Ele usa isso onde?
Só aqui baixo.
Eu também posso vir aqui e dar inline, está?
Então ele vai substituir onde tem o thisAmount por each ponto getAmount, está?
Dá para tirar esses comentários aqui não é?
O método já dá para entender melhor não é?
Bom, vou fazer a mesma coisa agora para os frequentRenterPoints está?
Então também vou começar a criar aqui na mão mesmo não é?
Então getTotalFrequentRenterPoints
e vou também copiar todo esse
pedaço aqui que pode ter alguma coisa a ver com isso.
E aí eu vou excluir as linhas que não tem a ver,
que é essa aqui que imprime e essa daqui também que imprime certo?
Então ele vai dar return frequentRenterPoints aqui.
[SEM_ÁUDIO] Certo.
E aqui também eu consigo já excluir algumas coisas.
O total de linhas de código não é?
Você pode perceber que ele não, por exemplo,
nesse método eu nem vou mexer mais com o frequentRenterPoints,
eu só vou imprimir o total ali está?
Então a gente pode ver aqui que essa,
esse método statement agora ele só,
só é responsável por essa parte de gerar o statement mesmo, está?
Opa, eu estou esquecendo de rodar o teste.
Deixa eu rodar aqui, antes que dê problema ali e eu não sei o que é que aconteceu.
ok, está?
Bom, aí pode vir o pessoal aí, que é muito preciosista relação
a desempenho e aí falar assim: Guerra, presta atenção no que você fez aí não é?
Você tinha ali loop, IO ali, aqui dentro do statement, onde você aproveitava para
calcular os frequentRenterPoints e você aproveitava para calcular o totalAmount.
Agora, você tem aqui loop, quando você chama o getTotalAmount
ele chama outro loop e quando você tem o total de frequentRenterPoints,
você ainda tem outro loop, está?
É, sim está?
Realmente muitas refatorações acabam piorando o desempenho do código está?
E aí eu chamo atenção para duas coisas.
A primeira coisa é que essa questão do desempenho,
você não pode ser aquele cara que reduzir o máximo desempenho do código, é, é, e
aí você vai gastar muito do seu tempo com uma coisa que talvez não agregue valor.
Então a primeira coisa que você tem que se perguntar
relação ao desempenho é: qual que é o requisito de desempenho?
Se, mesmo com aquela estrutura que não é ótima,
se mesmo assim atende ao requisito de desempenho.
Às vezes você está mexendo uma coisa que você vai ganhar 1 milissegundo,
enquanto você tem acesso a banco de dados que demora 50.
Então aquela otimização que você está fazendo, por mais que de repente sei
lá diminui pela metade o tempo daquele método, ela não vai ser significativa
termos de funcionalidade e para o cliente isso não vai fazer a menor diferença está?
Então, dito isso, o segundo ponto que eu queria falar é que muitas vezes
o código mais limpo e mais refatorado ele é muito mais fácil de você otimizar.
Vamos fazer isso aqui agora está?
Note que aqui eu tenho o frequentRenterPoints e o
getTotalAmount eles estão agora separados.
Com isso eu consigo o quê?
Eu consigo criar cash dessas informações.
Então eu posso vir aqui por exemplo e criar essas variáveis
aqui de frequentRenterPoints na minha classe, está?
Então eu vou colocar aqui private frequentRenterPoints e
eu posso vir aqui e colocar o totalAmount também como uma variável aqui, está?
Então o que é que eu posso fazer?
Toda a vez que eu adicionar, eu posso ao invés de calcular aquele total todas
as vezes, toda vez que eu adicionar uma locação, eu vou e já somo aquilo no total.
Então eu posso chamar quantas vezes eu quiser o getTotalAmount,
que ele não vai ficar repetindo esse cálculo está?
Então o que é que eu preciso fazer aqui?
Quando eu tenho é, é, é, quando eu adiciono elemento, eu vou vir aqui no meu,
eu vou até inicializar aqui, isso já estava pronto não é?
Mas eu vou arrumar direitinho está?
Então esse frequentRenterPoints aqui é, é, quando,
quando eu adicionar rental não é?
Eu vou vir aqui e vou somar isso não é?
Eu vou fazer essa linha aqui.
Eu vou passar essa linha aqui para cima,
e a mesma coisa aqui para o amount não é?
Eu também vou passar essa linha aqui para cima.
Só que aqui não vai ser mais o each não é?
Vai ser esse, está chamando de arg aqui, eu vou chamar de rental.
Para você ver como é que o código estava ruim, ele tinha uma variável chamada arg.
Quando eu vejo uma variável chamada arg, eu penso assim: argh.
Vamos lá.
Passei para cá, está?
Então agora eu estou fazendo cálculo,
eu estou meio que criando cash dessas informações está?
E agora o meu getTotalFrequentRenterPoints,
eu vou apagar isso tudo aqui e ele vai simplesmente retornar o que eu estou
guardando naquela variável, não é?
Nesse caso, eu estou é, é,
eu estou aqui no momento que eu adiciono uma nova locação,
ele já pega aqueles valores e já soma aí nessas variáveis está?
Então eu vou salvar, vou rodar, opa!
Pode pôr como unit test aqui está?
Ele roda e continua funcionando.
Olha a quantidade de código que eu tirei ali não é?
Aí você falou assim: quando você refatorou você tornou o código menos eficiente.
Mas justamente por ter refatorado é que eu tive a facilidade de criar esse cash.
Fazer isso enquanto estava lá no meio do statement teria sido bem mais
complicado está?
Então esse aqui é o nosso código final não é?
Da refatoração.
Espero que com essa, com essa sequência de vídeos você tenha visto como que é,
funciona essa questão da refatoração,
da importância dos testes para te dar segurança, está?
Felizmente aqui eu não quebrei nenhum teste durante a refatoração, mas é,
é, eu já fiz esse exercício outras vezes e já quebrei acidentalmente algum teste,
alguma coisinha que eu acabei deixando errado, ali pelo meio do caminho está?
Então ver essa dinâmica dos testes dentro da refatoração,
essa ideia de fazer pequenos passos e você ir rodando testes,
muitas vezes não é fácil, você sabe aonde você que chegar,
mas você não sabe exatamente quais passos que você precisa não é?
E a gente vai de pouquinho pouquinho melhorando o código e a gente pode ver
realmente, que era código bem mais complicado e a gente conseguiu é,
é, a partir da refatoração ir melhorando ele não é?
E até chegamos aqui num design, criamos subclasses,
começamos a utilizar polimorfismo não é?
Podemos até terminar aqui otimizando o desempemho está?
Último disclaimer aqui é que, se você pegar o livro do Martin Fowler, onde tem
essa refatoração, você vai ver que ele fez as coisas pouco diferente das que eu fiz.
Então, recomendo você a dar uma olhada lá para você ver que
não existe só uma solução para esse tipo de problema, está certo?
Muito obrigado por assistir,
espero que tenha enriquecido o conhecimento de refatoração de vocês.
Muito obrigado!
[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.
