[MÚSICA] [MÚSICA] Olá a todos,
eu sou Eduardo Guerra, bem vindos a mais hands-on.
Hoje a gente, a gente viu aquela aula, não é, do uso da interface Comparable, não é,
e nesse hands-on vamos ver como é que essa interface funciona, não é, como é que eu
faço, como é que eu crio uma classe e faço ela ser ordenada por método que já existe.
Então eu vou, vou criar aqui projeto, não é, que eu vou chamar de Concurso, certo?
Então eu vou colocar aqui criar projeto Java,
aí eu vou chamar aqui de Concurso que eu vou ordenar os candidatos, certo?
Então eu vou ter,
eu vou ter aqui, vamos lá,
vou criar aqui uma classe Candidato, certo?
Então bota aqui Candidato, certo,
e essa classe eu vou adicionar já nela aqui a interface Comparable,
certo, olha lá do java.lang Comparable, certo?
Então eu finalizo aqui ele já vai colocar o método compareTo, não é, não colocou?
Tudo bem, está, isso aqui utiliza os
tipos genéricos não é, eu vou colocar aqui,
quando eu coloco o compareTo eu tenho que dizer a quem ele pode ser comparado não é?
Então eu vou falar aqui que, opa, eu vou copiar aqui
eu vou dizer que ele pode ser comparado a outro candidato, não é?
Então vou chamar aqui do outro, certo?
Então o Candidato ele vai ter aqui 3 informações, certo?
Ele vai ter a nota, ele vai ter
se ele se cadastrou com uma deficiência, não é,
então deficiente, que concurso tem prioridade,
não é, e por fim vai ser a idade, certo?
Então vamos lá,
a primeira coisa que eu tenho que saber é se a nota é igual, não é?
Então se, o primeiro critério é a nota, não é,
olha aqui então para poder criar os candidatos eu vou criar aqui
construtor usando os campos, não é, o Eclipse já faz para mim,
certo, ele criou ali o meu construtor que recebe todas
as informações aí para eu poder fazer o teste depois, certo?
Então eu vou fazer aqui olha vou criar uns get
sets também não é, na verdade vou criar só get,
não é, então Source, Generate Getters and Setters,
olha lá, Select Getters, certo?
Então OK, ele colocou os getters ali botou uma distância
entre eles maior do que eu gostaria mas isso a gente arruma, vamos lá.
Então vamos lá, se a minha nota é
igual à nota do outro, certo,
aí eu tenho que comparar outro critério, certo?
Se não eu vou retornar, então aqui é assim se eu retorno
inteiro positivo quer dizer que ele,
ele é maior está?
Depois a gente testa se é isso mesmo, está, outro.getNota.
Então se a minha nota for maior ele é maior então esse,
vou retornar a minha nota menos a nota do outro, certo?
Já posso tirar esse return 0 aqui, está?
Então se a nota for igual eu tenho que ver se os dois são deficientes, não é?
Então se deficiente é igual a outro.deficiente está?
Se for igual eu vou resolver,
se não nesse caso vai ser,
aqui cima ou os 2 são deficientes ou os 2 não são deficientes, certo?
E aí então aqui eu vou fazer if deficiente,
return 1,
não é, que aí ele vai ser maior, se não return -1, está?
Bom nesses critérios de concurso normalmente se
eles tiveram a mesma nota ou se os 2 são ou não são deficientes,
o último desempate é na idade, não é,
aí se a idade for igual aí realmente eles empataram, não é?
Então vamos colocar aqui return
a minha idade menos a idade do outro,
certo, então se a minha for maior então eu vou ficar na frente,
certo, getIdade.
Aqui vez de usar o deficiente eu vou colocar aqui o isDeficiente, está?
Ok então esse aqui é o método compareTo não é?
Então eu vou vir aqui, vou criar aqui uma lista de candidatos,
então uma nova classe aqui,
chamar de principal não é, para a gente ver se está
ordenando direitinho aqui de acordo com o meu critério, está?
Então eu vou criar aqui uma lista, não é, de candidatos,
lista é igual a new
arrayList, opa vamos lá
arrayList, certo?
Ele vai reclamar aqui porque não tem import do list, não é,
a gente adiciona ali, certo?
E aí agora vamos adicionar candidatos na nossa lista.
Então lista.add candidato certo?
Vamos botar aqui new candidato,
que é que vamos colocar aqui?
Vamos fazer a nota até 100 então a nota esse aqui tirou 80,
não é, ele é deficiente e a idade dele é 30 anos,
certo?
[SEM ÁUDIO] esse daqui
também tirou 80 só que ele não é deficiente e a idade
dele é 25, certo?
Aí eu tenho outro aqui também que tirou 80 que também
não é deficiente mas ele, a idade dele é 28.
E aí por fim vamos ter aqui último candidato aqui mais,
mais tranquilo aqui, não é, que tem,
tirou uma nota melhor, não é, apesar de ter 20 anos só, não é?
Certo?
Vamos ver como que ele ordena isso aqui, certo?
Eu vou vir aqui no candidato, só para ficar mais fácil não é, todo, o objetivo,
ele tem método, então eu vou vir aqui, eu vou pedir uma ajudinha para o Eclipse,
Source, Override Implement Methods, eu vou sobreescrever o método da minha
superclasse, que é object, que é esse método toString, está,
é o método que ele usa para imprimir aquele objeto, está?
Então eu vou retornar a minha nota, certo,
vou botar aqui ponto e vírgula se ele
é deficiente e ponto
e vírgula, se ele é qualquer idade, está?
E essa aqui vai ser a forma de imprimir candidato.
[SEM ÁUDIO] Então eu vou vir aqui,
vou chamar aqui o Collections, certo,
deixa eu até já importar ele aqui,
é o Collections.sort.
Ele recebe ali a lista, não é,
e vai estar ordenando para mim essa, essa lista, está?
Então vamos ver agora, não é, vou percorrer aqui
a lista de candidatos, certo,
para ver se ele realmente ordenou direitinho, não é?
Então para cada candidato eu vou imprimir ele.
Aí fala assim " mas não precisa pegar as informações?" quando eu chamar isso daqui
ele vai chamar o método toString que foi esse aqui que eu defini, está?
Então eu vou rodar aqui [SEM
ÁUDIO] certo?
Então no caso aqui ele ordenou na
ordem do menor para o maior, não é,
significa que o primeiro colocado no concurso seria esse de 90, certo?
O segundo seria o que fez 80 e é deficiente, não é,
seria o de 80 que não é deficiente mas tem 28 anos porque ele é mais velho que esse
daqui, não é, ou seja ele está ordenando de acordo com o nosso critério ali, não é,
olha que interessante: eu tenho método já pronto mas que ele ordena
minha classe de acordo com o critério que eu defini
aqui e isso aqui é uma das aplicações de utilizar interfaces, está certo?
Espero que com esse exemplo prático aí tenha ficado mais claro
como que eu posso usar as interfaces para adicionar uma lógica
própria minha que vai ser invocado por método que já existe, que não entende,
não conhece a minha classe mas conhece a interface dela, está certo?
Muito obrigado, até ao próximo hands-on.
[MÚSICA] [MÚSICA]
