[MÚSICA] Eu
sou Eduardo Guerra e esse é o Curso de Desenvolvimento Ágil com Java Avançado.
Hoje vamos está falando aqui sobre tipos genéricos.
A ideia dessa primeira aula é você entender melhor como que os tipos
genéricos funcionam e como que, a partir deles,
você pode deixar o seu código mais seguro, certo?
Então, vamos contar uma historinha: imagina aí que você tem uma classe Cesta,
que você tem métodos nos quais você pode colocar itens, você pode retirar itens.
E aí, você tem método booleano que verifica se essa Cesta tem ou não item.
Então, a pessoa pegou, criou essa classe, como a gente pode ver: tanto o método que
coloca, recebe Object como parâmetro, quanto o método retira ele retorna Object.
Então a pessoa que fez falou: "uhu, uah, a minha classe é demais".
Porquê?
Ela pode aceitar qualquer tipo de objeto.
Então, como a gente pode ver aqui na Cesta, quando a gente coloca ou
quando a gente retira, como ele recebe Object, pode ser qualquer coisa não é?
Então, o cara estava se achando demais ali,
porque criou uma classe super genérica.
Só que tem porém, não é?
Será que colocar esse, poder colocar qualquer coisa ali,
não pode dar problema de quem colocar, colocar uma
coisa e quem retirar alguma coisa da Cesta, achar que é uma outra diferente?
Isso daí dar problema tempo de execução?
Vamos ver aqui exemplo.
Imagina que eu faça aqui o meu método que cria uma salada de frutas.
Então, eu recebo ali uma Cesta, certo?
Ele pega e cria uma nova instância de salada de frutas e,
enquanto eu ainda tiver itens na Cesta, que a ideia é que a Cesta vá retornando os
itens ali de forma aleatória, ele pega retira uma Fruta,
observa que no momento de retirar uma Fruta ele precisa fazer cast.
Então, ele chama retira e faz o cast para Fruta e, aí ele vai e manda cortar.
E depois que ele corta a Fruta, ele adiciona na salada.
E assim, ele vai enquanto a Cesta ainda tiver frutas.
Bom, se a gente pegar e passar uma Cesta só de frutas
para esse código, ele vai funcionar perfeito.
Agora, se a gente pegar e passar por exemplo uma cesta de gatinhos,
o quê que vai acontecer?
Você vai ali cortar o gatinho?
Não pode, não é?
O quê que acontece se a gente passar uma Cesta ali com outros tipos de objetos
que não sejam frutas?
Quando ele chegar ali no momento do cast, ou seja, ele retirar da Cesta e
tentar converter aquele objeto que ele não sabe qual é para uma Fruta,
isso daí vai dar ClassCastException, porque ele está
tentando atribuir para uma variável de tipo objeto que não é daquele tipo.
Então, a gente tem que tomar cuidado, porque a gente criar
código também que depende do que o cara passa como parâmetro para dar uma
exceção desse tipo, de ClassCastException, ele não é código seguro.
Então, a gente, esse tipo de código que conta com parâmetro,
que depende do parâmetro para funcionar, não é bom tipo de código.
Então, felizmente, vamos ver os tipos genéricos e como
eles podem nos salvar desse tipo de situação.
Uma Cesta agora vai receber E do lado, ali entre maior e menor,
que vai ser parâmetro que eu estou passando para o tipo.
Esse parâmetro, ele é diferente de parâmetro por exemplo de construtor,
porque eu estou passando parâmetro para o objeto.
Quando eu utilizo tipo genérico,
eu estou passando parâmetro para o tipo que eu estou criando.
Então, eu não estou criando mais só uma Cesta, eu estou criando uma Cesta de E,
uma Cesta de alguma coisa.
Pode ser uma Cesta de fruta ou pode ser uma Cesta de gatinho.
E aí, o quê que vai acontecer?
Esse E que eu referencio ali no meu tipo, eu posso utilizá-lo
na classe tanto para ser parâmetro quanto para ser retorno de método.
Então, eu posso colocar ali olha: coloca agora recebe E como parâmetro.
Então, o tipo que eu referenciar lá.
O retira agora ele retorna E, então, eu posso utilizar esse parâmetro.
Então, quando eu crio uma Cesta de Fruta, ele só aceita que eu coloque frutas e ele
só aceita que, quando eu retirar, ele vai retirar uma Fruta.
Vamos ver aqui.
Então, eu posso criar uma Cesta de Fruta e posso criar uma Cesta de Gato.
E aí, onde eu coloco que eu só aceito como parâmetro uma Cesta de Fruta,
eu não consigo passar outro tipo de Cesta.
Então, nesse caso aqui,
se eu colocar como parâmetro ali que eu só aceito Cesta de Fruta,
então, não tem mais o risco de eu passar ali uma Cesta de Gato.
E aí eu nem preciso mais fazer aquele cast para Fruta,
porque agora o meu método retira, ele já retorna o tipo genérico de E.
Então, ele vai retornar Fruta, eu não preciso mais nem fazer o cast, certo?
E aí o quê que acontece se eu tentar passar a Cesta de gatinho
ali para o meu método criarSalada?
Ele, tempo de compilação, ele vai dizer que
aquele objeto, ele não é do tipo que você espera como parâmetro.
Seria o mesmo caso de você tentar, por exemplo,
passar inteiro para o método que recebe uma String: na hora ali de compilar,
ele nem vai compilar o código, nem vai aceitar aquilo.
É melhor que a gente já receba esses erros tempo de compilação,
porque aí a gente nem chega a executar, nem chega a mandar para produção,
do que ter erro que a gente tenha que rodar o código para saber que ele existe.
E mais, a gente tem que rodar o código com parâmetro específico para saber que ele
existe, certo?
Então com isso daí olha, o gatinho adorou o código, porque não tem mais perigo de
você passá-lo para a Cesta e alguém querer cortá-lo ali com a faca.
Espero que essa aula tenha deixado claro aí o quê que são os tipos genéricos,
e como que utilizando-os você pode deixar o seu código mais seguro.
Mais seguro, não no sentido de security, mas no sentido de safety,
no sentido de que você criando código que utiliza os tipos genéricos,
você tem uma quantidade menor de erros que podem acontecer
tempo de execução e esses erros eles passam a acontecer tempo de compilação,
onde você tem feedback muito mais rápido daquilo que você está fazendo.
Se você usa bom IDE, como o Eclipse e o Netbeans,
já enquanto você está digitando ele já te avisa que aquilo ali é inválido, certo?
Então, muito obrigado.
Até a próxima aula!
[MÚSICA]
Clovis FernandesProfessor Titular in Portuguese
Eduardo GuerraProfessor Colaborador
