Um passeio pelo Java 5 - Generics

Classes Genéricas

Considere o código abaixo:

 
public interface List<E>
{
  void add(E x);
  Iterator<E> iterator();
}
   
public interface Iterator<E>
{
  E next();
  boolean hasNext();
}

As duas interfaces são definidas com o auxílio de parâmetros de tipos formais (formal type parameters), evidenciados pelas letras embutidas entre os sinais <>. Tipos paramétricos podem ser usados no código genérico de forma muito semelhante aos tipos convencionais. Um exemplo de utilização do código acima pode ser:

 
List<Integer> myList = new LinkedList<Integer>();
myList.add(new Integer(1));
Integer x = myList.iterator().next();

Até o Java 4 existiam apenas listas de Objects e para recuperar qualquer coisa diferente disso era necessário fazer um type cast. Agora pode-se definir a priori qual o tipo dos dados que uma lista (ou qualquer outra coleção) irá armazenar. Uma lista de inteiros receberá apenas inteiros, nada além disso. As conseqüências disso são várias:

• Não é preciso fazer cast para recuperar elementos já que o tipo correto de retorno já está especificado.
• O código fica mais robusto pois agora o compilador pode checar os tipos envolvidos (type safe) o que não acontecia quando um cast era necessário.
• Menos erros em tempo de execução.
• Exibe naturalmente um certo grau de reaproveitamento de código já que códigos genéricos são feitos para serem utilizados com tipos diferentes de dados.

Um ponto muito importante sobre generics está relacionado à subtipos. Considere o exemplo:

 List<String> ls = new ArrayList<String>();
  List<Object> lo = ls;

O que você acha do código acima? Já que String deriva de Object parece razoável supor que uma lista de strings também é um subtipo de uma lista de objetcs e sendo assim a atribuição acima estaria correta. Pois bem, considere esta continuação:

lo.add(new Object());
 String s = ls.get(0);

Na primeira linha um Object foi inserido na lista e na segunda este foi recuperado e atribuído a uma String, o que é um erro! Quando fizemos a variável lo receber ls esta deixou de ser uma lista apenas de strings e abriu a possibilidade de inserirmos qualquer tipo de objeto. Definitivamente este não é o tipo de comportamento que esperamos! É claro que atribuições como a acima não são permitidas e o compilador irá emitir uma mensagem de erro quando encontrá-las.

Dica - Se Circle é uma subclasse (ou subinterface) de Shape e G é uma declaração genérica qualquer então não é verdade que G<Circle> é também um subtipo de G<Shape>. Esta é uma noção inicialmente difícil de absorver pois vai contra nossa intuição natural.

Wildcards

A decisão acima é muito restritiva. Considere a necessidade de imprimir o conteúdo de uma coleção arbitrária e a tentativa de implementá-la exposta no método abaixo:

void printCollection(Collection<Object> c)
{
  for(Object e : c)
  {
     System.out.println(e);
   }
}

Como vimos, ao contrário da intuição inicial, esse não é um método apto a receber qualquer tipo de coleção, mas sim exclusivamente coleções que contêm objetos do tipo Object. Para representar uma coleção de qualquer coisa devemos usar o caractere ? da seguinte forma: Collection<?>. Isto é chamado de wildcard type. O novo código utilizando wildcard é:

  void printCollection(Collection<?> c)
{
  for(Object e : c)
  {
     System.out.println(e);
   }
}

o qual pode ser chamado com qualquer tipo de coleção. Observe que o conteúdo da coleção c é atribuído a um Object. O wildcard é um tipo desconhecido, mas como temos certeza que será um objeto é seguro atribuí-lo a uma variável do tipo Object.

Dica

Considere uma aplicação gráfica que desenha superfícies (shapes) tais como retângulos e círculos. Para representar esses componentes no programa podemos definir a seguinte hierarquia de classes:

Um método conveniente seria um para desenhar uma coleção de superfícies tal como:

 public void drawAll(List<Shape> shapes)
                     {
                       for(Shape s: shapes)
                       {
                         s.draw(this);
                       }
                     }

O problema aqui (novamente) é que esse método só pode ser invocado recebendo como parâmetro uma List<Shape>. Um List<Circle> por exemplo causaria erro de compilação. Isso é muito ruim tendo em vista que o objetivo do método é ler uma coleção de superfícies, sejam elas círculos ou retângulos. O que precisamos é de um método que aceite uma lista de qualquer tipo de superfície:

 public void drawAll(List<? extends Shape> shapes)
                     {
                       for(Shape s: shapes)
                       {
                         s.draw(this);
                      }
                     }

List<? extends Shape> é um exemplo de bounded wildcard. O ? representa, como antes, um tipo desconhecido. Entretanto, neste caso, sabemos que esse tipo é um Shape ou um subtipo deste. A desvantagem de não ser possível modificar uma variável com tipo desconhecido permanece.

Métodos Genéricos

Declarações de métodos também podem ser genéricas, isto é, parametrizadas por um ou mais parâmetro de tipo. Imagine como fazer um método que recebe um array de objetos e uma coleção e deve acrescentar todos os objetos do array dentro da coleção. Uma tentativa pode ser:

public void fromArrayToCollection(Object[] a, Collection<?> c)
{
   for(Object o : a)
   {
     c.add(o); //Erro de compilação!
    }
}

A opção de fazer Collection<?> para ser possível receber uma coleção arbitrária foi correta, porém, tornou a coleção c apenas para leitura. Se reformularmos este método como um método genérico podemos resolver esse problema:

 public <T> void fromArrayToCollection(T[] a, Collection<T> c)
{
   for(T o : a)
   {
     c.add(o); 
    }
 }

Podemos chamar este método com qualquer tipo de coleção cujos elementos sejam um supertipo dos elementos do array. Por exemplo:

Object[] objectArray = new Object[100];
Collection<Object> objectCollection = new ArrayList<Object>();
   
//Suponha as seguintes invocações do método fromArrayToCollection
fromArrayToCollection( Object, Object );  //Infere ser Object
fromArrayToCollection( String, Object );  //Infere ser Object
fromArrayToCollection( Integer, Number ); //Infere ser Number
fromArrayToCollection( Number, Object );  //Infere ser Object
fromArrayToCollection( Number, String );  //Erro de compilação!

Nas quatro primeiras chamadas do método o compilador pôde inferir um tipo válido para T, isto é, um tipo que é supertipo do outro. Perceba que não é necessário especificar explicitamente um tipo para um método genérico. O compilador irá inferir o tipo apropriado baseado nos tipos atuais. Na última chamada o método recebe como argumento um array de números e uma coleção de strings. Como String não é um supertipo de Number (e vice-versa) o compilador não consegue concluir um tipo válido e acusa erro.

Collection c = new ArrayList<String>();

  c.add(new Integer(10)); //unchecked warning

 ArrayList<Float> fl = c; //unchecked warning

public boolean containsAll(Collection<?>  c)

public <T> boolean containsAll(Collection<T>  c)

                         
public <T> T getSomething (T     something) {…}
public static <T> void     copy (List<T> dest, List<? extends T> src) {…}

 List<String> l1 = new ArrayList<String>();
                  List<Integer> l2 = new ArrayList<Integer>();
                  System.out.println(l1.getClass() == l2.getClass());

public static <T> T methodA(T[] array, T element) {…}
               
String[] sa = new String[10];
 
MethodA(sa, new String(“xx”)); //infere T = String – OK
MethodA(sa, new Integer(10)); //Consegue inferir T, mas como??

T = Object&Serializable&Comparable<? extends  Object&Serializable&Comparable<?>>

public static <T, S extends T> T methodA(T [] array, S element) {…} 

 Collection cs = new ArrayList<String>();
if(cs instanceof Collection<String>) {…}  //ilegal!!

 Collection<String> str = (Collection<String>) 
cs; // unchecked warning

<T> T badCast(T t, Object o) {return (T) o;} //unchecked warning

 List<String>[] L1 = new List<String>[10]; //Erro – tentativa de criar um array de genéricos
List<String>[] L2 = new List<?>[10]; //Erro – tipos incompatíveis 
List<?>[] L3 = new List<String>[10]; //Erro – tentativa de criar um array de genéricos

 List<?>[] lsa = new List<?>[10]; //OK - array de unbounded wildcard
lsa[0] = new ArrayList<Float>();
lsa[1] = new LinkedList<String>();
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(10));
lsa[3] = li;
Integer xx = (Integer) lsa[3].get(0); //É necessário um cast

Collection emps = sqlUtility.select(EmpInfo.class, “select * from emps”);

…
public static Collection select(Class c, String query)
{
  Collection result = new ArrayList();
 /* Executa a consulta */
 for(/* Itera no resultset */)
 {
    Object item = c.newInstance(); //Retorna um Object
    /* Utilize reflexao para setar os atributos do objeto baseado nos registros do banco*/
     result.add(item); //Povoa a coleção com Objects
  }
  return result;
}
   
Collection<EmpInfo> emps = sqlUtility.select(EmpInfo.class, “select * from emps”);
…
public static <T> Collection<T> select(Class<T> c, String query)
{
  Collection<T> result = new ArrayList<T>();
  /* Executa a consulta */
   for(/* Itera no resultset */)
    {
      T item = c.newInstance(); //Retorna um EmpInfo
      /* Utilize reflexao para setar os atributos do objeto baseado nos registros do banco*/
      result.add(item); // Povoa a coleção com o tipo específico
    }
 return result;
}