Semana 4 - Classes com tipos genéricos

Prévia do material em texto

Classes com tipos genéricos
Apresentação
A API Java tem uma funcionalidade criada para lidar com objetos de tipo seguro que tem como 
objetivo tornar o código fonte mais estável. Trata-se do Java Generics (Genéricos em Java), que 
permite o uso de uma declaração única de método em uma classe, com um conjunto de métodos e 
tipos relacionados.
 
Os tipos genéricos, ou parametrizados, aumentam a estabilidade dos tipos durante a compilação da 
aplicação. Eles são importantes, pois possibilitam criar classes, interfaces e métodos em que o tipo 
de dado utilizado é especificado como um parâmetro. Quando aplicados em uma classe ou método, 
eles passam a ser chamados, respectivamente, de classe genérica ou método genérico.
 
Nesta Unidade de Aprendizagem, você vai estudar sobre tipos e classes genéricas, assim como sua 
aplicação. Trata-se de um assunto fundamental para todos os programadores.
Bons estudos.
Ao final desta Unidade de Aprendizagem, você deve apresentar os seguintes aprendizados:
Definir o que é um tipo genérico.•
Reconhecer classes genéricas.•
Construir uma aplicação utilizando tipos genéricos.•
Infográfico
O uso de tipos genéricos em Java facilita o trabalho do programador, pois o poupa da elaboração 
de códigos redundantes. O código com genéricos funciona automaticamente com o tipo de dado 
definido para seu parâmetro de tipo. Isso quer dizer que você pode definir um algoritmo uma única 
vez, sem importar o tipo de dados, para, depois, aplicá-lo em uma variedade de tipos de dados sem 
um esforço adicional.
Neste Infográfico, você vai conhecer exemplos de listas de objetos de classes que utilizam e que 
não utilizam tipos genéricos e suas diferenças.
Aponte a câmera para o 
código e acesse o link do 
conteúdo ou clique no 
código para acessar.
https://statics-marketplace.plataforma.grupoa.education/sagah/890c9358-144a-45aa-92c5-ec7f9e9b04b9/f2ef855b-ecde-4b9f-9add-c889cc9d821a.png
Conteúdo do livro
Os genéricos adicionaram um elemento de sintaxe totalmente novo e causaram mudanças em 
muitas das classes e métodos da API principal. Não é exagero dizer que sua inclusão basicamente 
reformulou a natureza de Java.
No estudo que inicia no tópico Fundamentos dos tipos genéricos e finaliza em Tipos genéricos 
diferem de acordo com seus argumentos de tipo, do livro Java para iniciantes, base teórica desta 
Unidade de Aprendizagem, você confere uma abordagem sobre tipos genéricos.
Boa leitura.
Atualizado para JAVA SE 8 (JDK 8)
Java
para iniciantes
Crie, compile e execute programas Java rapidamente
Herbert Schildt
Catalogação na publicação: Poliana Sanchez de Araujo – CRB 10/2094
S334j Schildt, Herbert.
 Java para iniciantes : crie, compile e execute programas 
 Java rapidamente [recurso eletrônico] / Herbert Schildt ; 
 tradução: Aldir José Coelho Corrêa da Silva ; revisão 
 técnica: Maria Lúcia Blanck Lisbôa. – 6. ed. – Porto Alegre : 
 Bookman, 2015.
 Editado como livro impresso em 2015.
 ISBN 978-85-8260-337-6
 1. Linguagem de programação - Java. I. Título. 
CDU 004.438Java
O autor
O autor de best-sellers Herbert Schildt escreve incansavelmente sobre programação 
há quase três décadas e é uma das principais autoridades na linguagem Java. Seus 
livros de programação venderam milhões de cópias no mundo inteiro e foram tra-
duzidos para diversos idiomas. É autor de vários livros sobre Java, incluindo Java: 
The Complete Reference, Herb Schildt’s Java Programming Cookbook e Swing: A 
Beginner’s Guide. Ele também escreveu sobre C, C++ e C#. Embora tenha interesse 
em todas as áreas da computação, seu foco principal são as linguagens de progra-
mação, incluindo compiladores, interpretadores e linguagens de controle robótico. 
Também tem grande interesse na padronização de linguagens. Schildt tem gradua-
ção e pós-graduação pela Universidade de Illinois. Seu site é www.HerbSchildt.com.
O editor técnico
Dr. Danny Coward trabalhou em todas as edições da plataforma Java. Ele conduziu 
a definição dos Java Servlets para a primeira versão da plataforma Java EE e para 
além dela, os serviços web para a plataforma Java ME, e a estratégia e planejamento 
de Java SE 7. Fundou a tecnologia JavaFX e, mais recentemente, projetou o maior 
acréscimo feito ao padrão Java EE 7, a API Java WebSocket. Da codificação em Java 
ao projeto de APIs com especialistas da indústria e ao trabalho por vários anos como 
executivo do Java Community Process, ele adquiriu uma perspectiva singularmente 
ampla de vários aspectos da tecnologia Java. Além disso, é autor de JavaWebSo-
cket Programming e de um livro ainda a ser publicado sobre Java EE. Dr. Coward 
tem graduação, mestrado e doutorado em Matemática pela Universidade de Oxford.
Capítulo 13 Tipos genéricos 429
Principais habilidades e conceitos
• Entender as vantagens dos tipos genéricos
• Criar uma classe genérica
• Aplicar parâmetros de tipo limitado
• Usar argumentos curingas
• Aplicar curingas limitados
• Criar um método genérico
• Criar um construtor genérico
• Criar uma interface genérica
• Utilizar tipos brutos
• Aplicar a inferência de tipos com o operador losango
• Entender a técnica erasure
• Evitar erros de ambiguidade
• Conhecer as restrições dos genéricos
.....................................................................................................................................
Desde sua versão original, muitos recursos novos foram adicionados a Java. Todos melhoraram e expandiram seu escopo, mas o que teve impacto parti-
cularmente profundo e extenso foi o tipo genérico, porque seus efeitos foram sen-
tidos em toda a linguagem. Por exemplo, os genéricos adicionaram um elemento 
de sintaxe totalmente novo e causaram mudanças em muitas das classes e métodos 
da API principal. Não é exagero dizer que sua inclusão basicamente reformulou a 
natureza de Java.
O tópico “genéricos” é muito extenso e parte dele é avançado demais para 
entrar no escopo deste livro. No entanto, um conhecimento básico dos genéricos é 
necessário a todos os programadores Java. À primeira vista, a sintaxe dos genéricos 
pode parecer um pouco complicada, mas não se preocupe, os genéricos são muito 
fáceis de usar. Quando você terminar este capítulo, terá uma noção dos conceitos-
-chave que estão por trás dos genéricos e terá conhecimento suficiente para usá-los 
de maneira eficaz em seus próprios programas.
Fundamentos dos tipos genéricos
Na verdade, com o termo genéricos queremos nos referir aos tipos parametrizados. 
Os tipos parametrizados são importantes porque nos permitem criar classes, inter-
430 Java para Iniciantes
faces e métodos em que o tipo de dado usado é especificado como parâmetro. Uma 
classe, interface ou método que opera sobre um parâmetro de tipo é chamado de 
genérico, como em classe genérica ou método genérico.
Uma vantagem importante do código genérico é que ele funciona automatica-
mente com o tipo de dado passado para seu parâmetro de tipo. Muitos algoritmos são 
logicamente iguais, não importando o tipo de dado ao qual estão sendo aplicados. 
Por exemplo, uma classificação rápida é igual classificando itens de tipo Integer, 
String, Object ou Thread. Com os genéricos, você pode definir um algoritmo uma 
única vez, independentemente do tipo de dado, e então aplicá-lo a uma ampla varie-
dade de tipos de dados sem nenhum esforço adicional.
É importante entender que Java sempre permitiu a criação de classes, interfaces 
e métodos generalizados usando referências de tipo Object. Já que Object é a super-
classe de todas as outras classes, uma referência Object pode referenciar qualquer 
tipo de objeto. Logo, em códigos anteriores aos genéricos, classes, interfaces e méto-
dos generalizados usavam referências Object para operar com vários tipos de dados. 
O problema é que eles não faziam isso com segurança de tipos, já que coerções 
eram necessárias para converter explicitamente Object no tipo de dado que estava 
sendo tratado. Portanto, era possível gerar acidentalmente discrepâncias de tipo. Osgenéricos adicionam a segurança de tipos que estava faltando, porque tornam essas 
coerções automáticas e implícitas. Resumindo, eles expandem nossa habilidade de 
reutilizar código e nos permitem fazê-lo de maneira segura e confiável.
Exemplo simples de genérico
Antes de discutir mais teoria, é melhor examinarmos um exemplo simples de genéri-
co. O programa a seguir define duas classes. A primeira é a classe genérica Gen e a 
segunda é GetDemo, que usa Gen.
// Classe genérica simples.
// Aqui, T é um parâmetro de tipo que
// será substituído pelo tipo real quando
// um objeto de tipo Gen for criado.
class Gen<T> {
 T ob; // declara um objeto de tipo T
Declara uma classe genérica. T é o 
parâmetro de tipo genérico.
P: Ouvi dizer que os genéricos Java são semelhantes aos templates de C++. É isso 
mesmo?
R: Sim, os genéricos Java são semelhantes aos templates de C++. O que Java chama de 
tipo parametrizado, C++ chama de template. No entanto, os genéricos Java e os tem-
plates C++ não são iguais e há algumas diferenças básicas entre as duas abordagens 
de tipos genéricos. Geralmente, a abordagem Java é mais fácil de usar.
Uma advertência: se você tiver experiência em C++, é importante não tirar con-
clusões precipitadas sobre como os genéricos funcionam em Java. As duas abordagens 
de código genérico diferem de maneiras sutis, mas básicas.
Pergunte ao especialista
Capítulo 13 Tipos genéricos 431
 // Passa para o construtor uma
 // referência a um objeto de tipo T
 Gen(T o) {
 ob = o;
 }
 // Retorna ob.
 T getob() {
 return ob;
 }
 // Exibe o tipo de T.
 void showType() {
 System.out.println("Type of T is " +
 ob.getClass().getName());
 }
 }
// Demonstra a classe genérica.
class GenDemo {
 public static void main(String args[]) {
 // Cria uma referência Gen para Integers.
 Gen<Integer> iOb;
 // Cria um objeto Gen<Integer> e atribui sua
 // referência a iOb. Observe o uso do autoboxing no
 // encapsulamento do valor 88 dentro de um objeto Integer.
 iOb = new Gen<Integer>(88);
 // Exibe o tipo de dado usado por iOb.
 iOb.showType();
 // Obtém o valor de iOb. Observe
 // que nenhuma coerção é necessária.
 int v = iOb.getob();
 System.out.println("value: " + v);
 System.out.println();
 // Cria um objeto Gen para Strings.
 Gen<String> strOb = new Gen<String>("Generics Test");
 // Exibe o tipo de dado usado por strOb.
 strOb.showType();
 // Obtém o valor de strOb. Novamente, observe
 // que nenhuma coerção é necessária.
 String str = strOb.getob();
 System.out.println("value: " + str);
 }
}
Cria uma referência a um 
objeto de tipo Gen<Integer>.
Instancia um objeto 
de tipo Gen<Integer>.
Cria uma referência e um 
objeto de tipo Gen<String>.
432 Java para Iniciantes
A saída produzida pelo programa é mostrada abaixo:
Type of T is java.lang.Integer
value: 88
Type of T is java.lang.String
value: Generics Test
Examinemos esse programa com detalhes. Primeiro, observe como Gen é de-
clarada pela linha a seguir:
class Gen<T> {
Aqui, T é o nome de um parâmetro de tipo. Esse nome é usado como espaço reser-
vado para o tipo real que será passado para Gen quando um objeto for criado. Logo, 
T será usado dentro de Gen sempre que o parâmetro de tipo for necessário. Observe 
que T está dentro de < >. Essa sintaxe pode ser generalizada. Sempre que um pa-
râmetro de tipo estiver sendo declarado, ele será especificado dentro de colchetes 
angulares (< >). Já que Gen usa um parâmetro de tipo, é uma classe genérica.
Na declaração de Gen, não há um significado especial no nome T. Qualquer 
identificador válido poderia ter sido usado, mas o uso de T é tradicional. Além disso, 
é recomendável que os nomes dos parâmetros de tipo tenham apenas um caractere: 
uma letra maiúscula. Outros nomes de parâmetros de tipo normalmente usados são 
V e E.
Em seguida, T é usado para declarar um objeto chamado ob, como mostrado 
abaixo:
T ob; // declara um objeto de tipo T
Como explicado, T é um espaço reservado para o tipo real que será especificado 
quando um objeto Gen for criado. Logo, ob será um objeto do tipo passado para T. 
Por exemplo, se o tipo String for passado para T, então, nesse caso, ob será de tipo 
String.
Agora, considere o construtor de Gen:
Gen(T o) {
 ob = o;
}
Observe que seu parâmetro, o, é de tipo T. Ou seja, o tipo real de o será determinado 
pelo tipo passado para T quando um objeto Gen for criado. Além disso, já que tanto 
o parâmetro o quanto a variável membro ob são de tipo T, ambos terão o mesmo tipo 
quando da criação de um objeto Gen.
O parâmetro de tipo T também pode ser usado para especificar o tipo de retor-
no de um método, como ocorre com o método getob( ), mostrado aqui:
T getob() {
 return ob;
}
Já que ob também é de tipo T, seu tipo é compatível com o tipo de retorno especifi-
cado por getob( ).
Capítulo 13 Tipos genéricos 433
O método showType( ) exibe o tipo de T. Ele faz isso chamando getName( ) 
no objeto Clas retornado pela chamada a getClass( ) em ob. Não usamos esse recur-
so antes, logo, vamos examiná-lo em detalhes. Você deve lembrar que, no Capítulo 
7, vimos que a classe Object define o método getClass( ). Portanto, getClass( ) é 
membro de todos os tipos de classe. Ele retorna um objeto Class correspondente ao 
tipo de classe do objeto em que foi chamado. Class é uma classe definida dentro de 
java.lang que encapsula informações sobre outra classe. Ela define vários métodos 
que podem ser usados na obtenção de informações sobre uma classe no tempo de 
execução. Entre eles, está o método getName( ), que retorna uma representação do 
nome da classe na forma de string.
A classe GenDemo demonstra a classe genérica Gen. Primeiro, ela cria uma 
versão de Gen para inteiros, como vemos abaixo:
Gen<Integer> iOb;
Examine bem essa declaração. Primeiro, observe que o tipo Integer é especificado 
dentro de colchetes angulares após Gen. Nesse caso, Integer é um argumento de tipo 
que é passado para o parâmetro de tipo de Gen, que é T. Isso cria uma versão de Gen 
em que todas as referências a T são convertidas para referências a Integer. Logo, 
para essa declaração, ob é de tipo Integer e o tipo de retorno de getob( ) também.
Antes de prosseguirmos, é preciso dizer que o compilador Java não cria real-
mente versões diferentes de Gen ou de qualquer outra classe genérica. Embora seja 
útil pensar assim, não é o que acontece. Em vez disso, o compilador remove todas as 
informações do tipo genérico, substituindo pelas coerções necessárias, para fazer o có-
digo se comportar como se uma versão específica de Gen fosse criada. Logo, na ver-
dade, há apenas uma versão de Gen no programa. O processo de remover informações 
do tipo genérico se chama erasure e ele será discutido posteriormente neste capítulo.
A próxima linha atribui a iOb uma referência a uma instância de uma versão 
Integer da classe Gen.
iOb = new Gen<Integer>(88);
Observe que quando o construtor de Gen é chamado, o argumento de tipo Integer 
também é especificado. Isso é necessário porque o objeto (nesse caso, iOb) ao qual a 
referência está sendo atribuída é de tipo Gen<Integer>. Logo, a referência retornada 
por new também deve ser de tipo Gen<Integer>. Se não for, ocorrerá um erro de 
tempo de compilação. Por exemplo, a atribuição a seguir causará um erro de tempo 
de compilação:
iOb = new Gen<Double>(88.0); // Erro!
Já que iOb é de tipo Gen<Integer>, não pode ser usada para referenciar um objeto 
de Gen<Double>. Esse tipo de verificação é um dos principais benefícios dos gené-
ricos porque assegura a segurança dos tipos.
Como os comentários do programa informam, a atribuição
iOb = new Gen<Integer>(88);
faz uso do autoboxing para encapsular o valor 88, que é um int, em um Integer. 
Isso funciona porque Gen<Integer> cria um construtor que recebe um argumento 
434 Java para Iniciantes
Integer. Já que um Integer é esperado, Java encapsularáautomaticamente 88 dentro 
dele. É claro que a atribuição também poderia ter sido escrita explicitamente, da 
seguinte forma:
iOb = new Gen<Integer>(new Integer(88));
No entanto, não teríamos vantagem usando essa versão.
Em seguida, o programa exibe o tipo de ob dentro de iOb, que é Integer. De-
pois, obtém o valor de ob usando a linha abaixo:
int v = iOb.getob();
Como o tipo de retorno de getob( ) é T, que foi substituído por Integer quando iOb 
foi declarada, ele também é Integer, que é encapsulado em int quando atribuído a v 
(que é um int). Logo, não há necessidade de converter o tipo de retorno de getob( ) 
para Integer.
Agora, GenDemo declara um objeto de tipo Gen<String>:
Gen<String> strOb = new Gen<String>("Generics Test");
Como o argumento de tipo é String, T é substituído por String dentro de Gen. Isso 
cria (conceitualmente) uma versão String de Gen, como as linhas restantes do pro-
grama demonstram.
Genéricos só funcionam com tipos de referência
Na declaração de uma instância de um tipo genérico, o argumento de tipo passado 
para o parâmetro de tipo deve ser um tipo de referência. Você não pode usar um tipo 
primitivo, como int ou char. Por exemplo, com Gen, é possível passar qualquer tipo 
de classe para T, mas você não pode passar um tipo primitivo para T. Logo, a decla-
ração a seguir é inválida:
Gen<int> intOb = new Gen<int>(53); // Erro, não pode usar um tipo primitivo
Certamente, não poder especificar um tipo primitivo não é uma restrição grave, por-
que você pode usar os encapsuladores de tipos (como fez o exemplo anterior) para 
encapsular um tipo primitivo. Além disso, o mecanismo Java de autoboxing e autou-
nboxing torna o uso do encapsulador de tipos transparente.
Tipos genéricos diferem de acordo com seus 
argumentos de tipo
Um ponto-chave que devemos entender sobre os tipos genéricos é que uma referên-
cia de uma versão específica de um tipo genérico não tem compatibilidade de tipo 
com outra versão do mesmo tipo genérico. Por exemplo, supondo o programa que 
acabei de mostrar, a linha de código abaixo está errada e não será compilada:
iOb = strOb; // Errado!
Ainda que tanto iOb quanto strOb sejam de tipo Gen<T>, são referências a tipos 
diferentes porque seus argumentos de tipo diferem. Isso faz parte da maneira como 
os genéricos adicionam segurança de tipos e evitam erros.
Dica do professor
Os itens e as funções de uma classe genérica podem ser generalizados com um parâmetro (a letra 
T, por exemplo) para especificar se pode ser adicionado qualquer tipo como um parâmetro no lugar 
de T — sejam esses tipos Integer, String, Double ou qualquer outro que for definido pelo usuário. A 
declaração de uma classe genérica e de uma não genérica é igual. O que muda é que o nome da 
classe é seguido por uma seção com o tipo de parâmetro.
O ponto em comum em todas as declarações de tipo ou método genérico é que elas têm uma seção 
de parâmetro de tipo indicada pelos símbolos angulares <> (símbolos de maior e menor que). Cada 
uma das seções de parâmetro de tipo pode ter um ou mais parâmetros, desde que separados por 
vírgula.
Nesta Dica do Professor, confira um exemplo em que um objeto de uma classe é incluído com o 
tipo T, que poderá ser substituído quando necessário.
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
https://fast.player.liquidplatform.com/pApiv2/embed/cee29914fad5b594d8f5918df1e801fd/b1edb4cbc695dca099e72bd9086cb68b
Exercícios
1) Os tipos genéricos também têm diversas vantagens, como o aumento da estabilidade dos 
tipos durante a compilação da aplicação. Sobre os tipos genéricos, veja as afirmações a 
seguir:
I. O tópico genérico é extenso.
II. Genéricos são tipos primitivos de dados.
III. Ao declarar um atributo como String, declara-se que ele é um genérico.
IV. Ao usar tipos genéricos, é possível definir um algoritmo uma única vez.
V. Com genéricos, o código pode ser reutilizado.
Está correto o que se afirma em:
A) I, III e IV.
B) II, IV e V.
C) I, IV e V.
D) III e IV.
E) II, III e IV.
2) Os tipos genéricos são úteis em diferentes tipos de sistemas e aplicações, com uma função 
específica. 
Nesse contexto, assinale a alternativa que descreve a que se refere o termo “genéricos” no 
conceito dos tipos genéricos:
A) A estrutura de herança.
B) Um tipo primitivo de dados que pode receber qualquer valor.
C) Uma aplicação que pode ser executada sem o método main em Java.
D) Duas variáveis de referência ao instanciar uma classe.
E) Tipos de dados parametrizados.
3) A aplicação de tipos genéricos em um código-fonte depende da utilização de uma sintaxe de 
código específica. Nesse sentido, observe os modelos de trechos de códigos-fonte a seguir e 
os relacione com suas respectivas descrições:
I. class NomeDaClasse{ //implementação. }
II. class abstract NomeDaClasse{ //implementação.
III. class NomeDaClasse extends Generica{ //implementação. }
IV. class NomeDaClasse implements Generica{ //implementação. }
V. class NomeDaClasse <Parâmetro de tipo>{ //implementação. }
( ) Declara um parâmetro de tipo genérico para a classe.
( ) Declara uma classe abstrata.
( ) Informa que a classe está implementando uma interface com o nome “Generica”.
( ) Sintaxe básica de declaração de classes.
( ) Informa que a classe é uma extensão da classe com o nome “Generica”.
Assinale a alternativa que apresenta a ordem correta.
A) V, IV, II, III, I.
B) IV, III, V, I, II.
C) III, I, II, IV, V.
D) IV, II, III, I, V.
E) V, II, IV, I, III.
A sintaxe de um código-fonte é muito importante para que a aplicação seja implementada e 
executada da maneira correta com todos os seus recursos, inclusive os tipos genéricos que 
forem definidos.
Nesse sentido, observe o código-fonte a seguir:
4) 
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
https://statics-marketplace.plataforma.grupoa.education/sagah/905739f4-99a9-4091-9352-1c50da7dfdd5/91fe4dbf-b737-441c-bdcf-906c3fec8231.png
Analise as afirmações a seguir sobre o código apresentado:
I. Na linha 1, a letra “T” representa o nome de um parâmetro de tipo.
II. O código da linha 2 provocará um erro de compilação pela falta de um tipo válido para o 
atributo “ob”.
III. Nas linhas 10, 11 e 12, tem-se o método “getob()”, que retorna um tipo “T”.
IV. Na linha 28, é criada uma versão de “Gen” para inteiros e atribuída uma referência a 
“iOb” a uma instância da classe “Generica”.
Está correto o que se afirma em:
A) I, II e III.
B) I e III.
C) II e III.
D) II, III e IV.
E) II e IV.
5) A utilização de tipos genéricos na API Java depende de algumas características específicas, 
que envolvem as classes e seus parâmetros. 
Nesse contexto, veja as afirmações a seguir:
I. Genéricos funcionam com qualquer tipo de dados.
II. Tipos genéricos diferem de acordo com seus argumentos de tipo.
III. Classes genéricas podem ser declaradas com mais de um parâmetro.
IV. É recomendável que os nomes de parâmetros de tipos tenham exclusivamente uma letra.
V. As letras a serem utilizadas como nomes de parâmetros de tipos devem ser “T”, “E” ou 
“V”.
Está correto o que se afirma em:
A) I, III e IV.
B) II, IV e V.
C) I, IV e V.
D) III e IV.
E) II, III e IV.
Na prática
Quando se define um parâmetro de tipo, ou tipo genérico, é recomendável empregar apenas uma 
letra maiúscula para o nome desse parâmetro. Geralmente, são usadas as letras “T”, “E” ou “V”. De 
toda forma, pode ser feito o uso de outros caracteres e até mesmo de nomes com mais de um 
caractere.
Entre os métodos utilizados em Java, está o showType, que mostra o tipo da variável ou atributo a 
que for referenciado, deixando claro que o tipo parametrizado é genérico ou não. Outro conceito 
importante é o das classes de controle, que são aquelas que contêm toda a lógica propriamente dita 
da aplicação e que têm ligação com as visões que ela apresenta ao usuário.
Neste Na Prática, confira um exemplo de código-fonte que utiliza os conceitos de tiposgenéricos 
em classes, inclusive em uma classe de controle. Para o exemplo, é utilizado o Integrated 
Development Environment ou Ambiente de Desenvolvimento Integrado (IDE) NetBeans. 
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
https://fast.player.liquidplatform.com/pApiv2/embed/cee29914fad5b594d8f5918df1e801fd/83353c0348dcdbcc879d875c1bb7ccf2
Saiba +
Para ampliar o seu conhecimento a respeito desse assunto, veja abaixo as sugestões do professor:
Usando Generics em Java
Veja, neste artigo, os principais usos e especificações dos tipos genéricos na API Java.
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
Introdução: sobrecarga de métodos e tipos genéricos em Java
Veja, neste artigo, como e quando utilizar sobrecarga de métodos e tipos genéricos e quais 
problemas cada um ajuda a resolver.
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
Tipos genéricos com os objetos ArrayList e Iterator
Para conhecer um exemplo do uso de tipos genéricos em Java com os objetos ArrayList e Iterator, 
consulte o conteúdo presente nas páginas 631 a 633 do livro Android: como programar, de Paul 
Deitel, Harvey Deitel e Abbey Deitel.
Conteúdo interativo disponível na plataforma de ensino!
Tipos genéricos para códigos dinâmicos
Neste vídeo, você vai ver alguns conceitos e exemplos comentados de códigos-fonte com tipos 
genéricos.
https://www.devmedia.com.br/usando-generics-em-java/28981#:~:text=Existem%203%20tipos%20de%20Wildcards,Super%20wildcard 
https://www.devmedia.com.br/introducao-sobrecarga-de-metodos-e-tipos-genericos-em-java/22853
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
https://www.youtube.com/embed/r5qc5YGNcMA