Salve! Salve! Pessoal! Mais um post da série Revisão SCJP. No ultimo post falei sobre Conjuntos/Collection e aproveitando o ritmo vou falar hoje sobre Generics/genéricos que foi adicionado ao Java 5 e consta no exame 310-055. Nessa coluna as explicações serão mais a nível de código então fique atento aos comentários.
Aos estudantes SCJP se liguem nas pegadinhas que pode constar no seu exame.
Let’s GO…
Pré-Requisito
– Instalação Java 1.5/superior
Last Column Java – Imasters /Ultima Coluna Java – Imasters:
Instalando e configurando ambiente JEE Netbeans 6
Summary
This article presents a theory and practice about Generics. Generics are one subject that is present in the exam 310-055 and there are several questions about this subject. When I did my exam I did, about seven questions with generics and some lots difficult.
Generics serve for specific the type of Collection.
In the Java 5, you can specific that type of object your Collection can to get. I spoke Object, pay attention for not confuse with type primitives. Check the example Ex.1 below.
The Ex.2 not compile because I try to add object different this Collection, see: ist.add(“camilo”);
It is impossible, because we have one Collection of the type Integer.
Genéricos
Os genéricos ele servem para especificar o tipo de conjunto. Ou seja, manter a proteção dos objetos para aquele determinado conjunto. “Procure não colocar maça na caixa de uva”.
No Pré-Java 5 não era possível informar que tipo de conjunto. Veja:
Ex.1
List l = new ArrayList();
l.add(“74”);
l.add(new Dog(“dd”));
//recebe qualquer coisa
No Java 5 você especificar que tipo de objeto seu conjunto pode receber. Eu falei OBJETO cuidado para não confundir com tipos PRIMITIVOS.
Ex.2
List<Integer> ist = new ArrayList<Integer>();
ist.add(99);
ist.add(44);
ist.add(“camilo”);//erro de compilação não pode receber String somente Integer
Para o exame/sua vida como programador você não pode esquecer os pontos abaixo referente a genéricos:
-Se usar Java 5 com pré-Java sua proteção vai para o “saco do lixo”, ele aceita qualquer coisa pensando que ta recebendo o tipo especifico.
– Os erros com GENÉRICOS são de compilação e não tempo de execução a não ser um quando acontece Cast que não seja possível.
-Para a JVM em tempo de execução você está usando o pré-java, pois senão lançaria uma exceção.
-O compilador ele que fica encarregado de verificar se esta tudo ok.
-Compilar códigos com avisos não quer dizer erro de compilação. O compilador apenas avisa que ali a algo inseguro.
-As proteções(tipos) nos conjuntos NÃO EXISTEM EM TEMPO DE EXECUÇÃO
-Os tipos dos conjuntos(<Integer>, <Double> etc.) são destruídos em tempo de execução.
Vejamos alguns exemplos:
//uso um tipo especifico mais passo para um não especifico proteção já era
import java.util.*;
class TestBad{
public static void main(String [] agrs){
List<Integer> list = new ArrayList<Integer>();
list.add(4);
list.add(9);
list.add(10);
Inserter in = new Inserter();
in.insert(list);
System.out.println(list);
}}
class Inserter{
void insert(List list){
list.add(new Integer(42));
list.add(new String(“camilo”));
list.add(new Double(3.9));
}}
/*está confuso? Por que adicionou uma String ao ArrayList de Integer ?
Observe que a classe que o método insert recebe qualquer objeto e adiciona à lista os desenvolvedores tiveram que manter isso, para que evitasse uma mudança desastrosa, para aos pré-java*/
/*mas é importante ter cuidado com isso no exame ele vai confundir ao infinito e ficar brincando com Java 5 e pré-Java 5. Genéricos é um bom assunto para brincar */
O código acima compila com avisos já que temos um conjunto não seguro. Se o método da classe Inserter for modificado para void insert(List<Integer> list) o código não compila, pois somente posso ter conjunto Integer e estou adicionando ao meu conjunto outros objetos.
A idéia de conjunto o interessante é pensar como um Barril experimente colocar dentro de um barril de polvora(Integer) algo que gere Calor(Double) eu acho que explode e você? (não compila).
Vamos a outro exemplo:
import java.util.*;
class ConverPre{
public static void main(String agrs[]){
List lit = new ArrayList();
lit.add(58);
System.out.print(lit + ” “);
}}
No pré Java 5 isso não funcionava já que o Boxing não é feito de forma automática. Mas se encontrar uma questão assim no exame 310-055 pode marcar que compila e executa.
Nesse ultimo exemplo apresento como pode acontecer uma exceção no caso de genéricos:
import java.util.*;
public class GeneriList {
//esse metodo nao quebra nenhuma regra
static void adde(List lt){
lt.add(new String(“neto”));}
public static void main(String[] args) {
ArrayList<Integer> lis = new ArrayList();
lis.add(10);
lis.add(50);
adde(lis);
System.out.println(lis);
for(Integer it : lis){
int z = it;
System.out.println(z);}}}
Ele lança uma exceção por ter adicionado algo indevido no meu conjunto e quando fui retirar os elementos do conjunto achei que somente tinha Integer, porém fui enganado e vi uma exceção.
A proteção foi para o saco quando o método adde (pre-java 1.5) foi misturado com código que usa Java 5, mais o maior erro foi adicionar lt.add(String). Se fosse um Integer não teríamos problema.
A exceção ocorre tentar passar uma String para um Integer. O meu for espera um Integer do meu conjunto e não uma String.
Uma situação como acima pode acontecer com um programador que não conhece as regras de genéricos e se na equipe de desenvolvimento não contar com algum programador com o conhecimento a resolução para essa exceção pode consumir alguns minutos/horas e quem sabe gerar uma gambiarra.
Essas são as questões faz parte do grupo das mais difíceis do exame e como a Sun não dar colher de chá a maioria das questões que envolver genéricos vai ser nesse nível (pelo menos as minhas foram).
A dica é: “Estude para aprender e para passar no exame!”
Vou ficando por aqui! E na próxima coluna vou continuar o assunto de genéricos abordando polimorfismo e genéricos como eles se entendem? Aguarde até o próximo post.
Um abraço a todos! E até próxima!