[MÚSICA] [MÚSICA] Olá a todos, eu sou Eduardo Guerra, estamos aqui no curso de orientação a objetos com Java. Hoje eu vou nesse hands-on mostrar pouquinho sobre interfaces, polimorfismo, para você entender pouquinho como que isso daí funciona. Está certo? E aí eu vou fazer exemplo bem simples mas para demonstrar mesmo o conceito. O que eu vou fazer, eu vou criar aqui projeto, vou chamar ele de Interfaces. Dentro desse projeto eu vou criar várias classes, vou criar uma interface chamada Barulho, certo, onde, sei lá, a classe ela vai retornar a uma string que é o barulho que ela faz, está? E aí, a partir disso, eu vou criar uma lista desses objetos com barulho e a gente vai ver como que funciona aí esse, essa questão aí do polimorfismo, que método com o que ele chama cada. Está certo? Então eu vou começar criando aqui minha interface, vou chamar de Barulhento, certo? Nessa interface eu vou definir o método fazer barulho, ok? E aí eu vou criar algumas classes aqui vou criar aqui, por exemplo a classe cachorro, certo? Que, o cachorro vai ser barulhento, certo? Então vou colocar aqui implements barulhento, não é? Tem cachorro que é mesmo, não é? E aí ele dá a opção aqui, note que ele deixa errado. Porquê? Porque ele está implementando uma interface, mas não implementou os métodos dela, não é? Então eu posso pedir ajuda aqui para o meu amigo Eclipse, certo? Lá, ele sugere aqui: ou eu deixo o cachorro abstrato ou eu adiciono os métodos não implementados. Vou criar aqui essa opção e o "cachorro" aqui, quando faz barulho, ele vai fazer "au au", certo? Bom, vamos criar uma outra classe, imagine aqui, ele pode herdar de animal e etc., nã oé? Vou ter aqui uma outra classe que vai ser carro, certo? Também vou colocar aqui implements Barulhento, certo? Ele vai reclamar da mesma coisa, que eu não adicionei o método, ajuda aí Eclipse, certo? Então eu vou vim aqui, vou retornar "vrum vrum bi bi", pronto, certo? Para finalizar quero último, última coisa que faz barulho aí. Vou solicitar a ajuda aqui da minha plateia. Fala alguma coisa aí que faz barulho! Bateria! Muito bom. Então vamos criar aqui uma nova classe aqui chamado bateria, né? Note que são classes assim, completamente diferentes. Agora eu vou fazer diferente, eu já vou vir aqui no próprio Eclipse já vou informar aqui que a minha bateria é barulhenta. E aí quando eu marco aqui o inherit abstract methods, quando eu der o finish aqui eu vou até tirar aqui os construtores. Quando eu der finish aqui, note que ele já vai colocar pra mim o método ali. Está certo? Aqui como que é o barulho da bateria, vamos ver "pum pum tá tá ptiz". Que é o pst no final não é, sei lá alguma coisa assim. Minhas onomatopeias, é isso mesmo, certo? Não estão lá muito sofisticadas, mas dá pra, serve para o exemplo aqui. Então vamos criar aqui agora a nossa classe principal, certo, para gente ver como que funciona aqui esse polimorfismo. Vamos marcar aqui o método main, certo? Então o que eu vou fazer? Eu vou criar array de barulhento. Barulhentos, certo? Vai ser arraid de 10 barulhentos, certo? E vou colocar aqui, não é, barulhento, certo? Então vou colocar aqui os vários objetos. Então "cachorro", não é? Vou colocar aqui, vou dar qual é o problema aqui? Está, é barulhentos, certo? Então, cachorro. Vou dar uns control c + control v aqui, 3, 6, até 9, não é? Então vamos colocar aqui vários barulhentos diferentes, certo? 8, 9, não é, o segundo aqui pode ser new carro. Deixa outro cachorro, dois cachorros, mais uma bateria, certo? Mais aqui uns três carros. Na verdade ele tem mais carros e cachorros do que bateria, essa é a verdade. Mas uma bateria aqui e termina com mais cachorro, certo? Eu vou criar outro método aqui que vai ser o faz barulho. É o que tem ali no Barulhento, não, é fazer barulho. Como que é, barulhar, não, não existe isso, sons, pronto, sons e aí ele vai receber array de barulhentos, certo? Então aqui esses sons, a gente simplesmente vai fazer o seguinte para cada barulhento, nos barulhentos, certo, ele vai imprimir no console b.fazer barulho, certo? E aí aqui, no meu método principal, eu vou vim aqui e chamar os sons passando ali os barulhentos, certo? Muito bom. Então eu salvo aqui, certo, e vou rodar. Quando eu executo, eu posso ver aqui que o que ele colocou ali, primeiro era o cachorro, depois era o carro, cachorro, cachorro, a bateria, carro, carro, carro, bateria, cachorro. Então apesar aqui dele receber uma lista, não é, que ele não sabe o que é, a princípio são barulhentos, ele vai chamar o método que eu defini cada uma das classes, está? Essa é a ideia do polimorfismo, não é? Aí vamos supor que eu tenho isso aqui e decido criar uma nova classe barulhenta, não é, vou criar aqui, deixa eu ver, uma coisa bem barulhenta, vuvuzela. Nem sei como que escreve isso daqui, vai ser com "z" mesmo, não é? Já vou adicionar aqui à interface barulhento pra me facilitar, certo? E a vuvuzela, eu não sei como escrever o barulho dela, mas seria alguma coisa assim "VRUUUUUUMMM". Não isso tá mais para o carro, não é? "VRUUUUUUUUUXXXXXUUUUUU", sei lá. Por favor, não me julguem, não julguem meus barulhos, certo? Então vamos voltar, sem barulho, eh se eu botar aqui new vuvuzela, certo? Então no sexto lugar ali ele tem que chamar este método novo que eu acabei de criar. Note que esses sons nem sabem que existe vuvuzela, certo? Então quando eu rodar aqui, certo? Lá ele tá vuvuzela ali no meio sendo chamada. Então com isso, implementando aquela interface, o método, aqui, sons, ele não precisa conhecer cada uma das classes, não precisa saber qual o método de cada uma das classes, ele só precisa conhecer a interface e cada [INAUDIBLE] precisa estar implementando aquela interface. Está certo, então essa ideia de interface, essa ideia do polimorfismo que você pode estar passando essa classe no lugar de qualquer classe que implementa interface no lugar onde ele aceita uma interface daquele tipo, está? Espero que essa questão tenha ficado mais clara pra você vendo aqui na prática e até a nossa próxima aula. [MÚSICA] [MÚSICA]
