Curingas limitados

• Argumentos curingas podem ser limitados, assim como parâmetros de tipo, para restringir os tipos usados.

• Curingas limitados são úteis para métodos que devem operar apenas com objetos que são subclasses de uma superclasse específica.

• Um exemplo prático demonstra essa funcionalidade.

class A {
// ...
}
class B extends A {
// ...
}
class C extends A {
// ...
}
// Observe que D NÃO estende A.
class D {
// ...
}

• Aqui, a classe A é estendida pelas classes B e C, mas não por D.

// Classe genérica simples.
class Gen<T> {
T ob;
Gen(T o) {
ob = o;
}
}

• Gen usa um parâmetro de tipo T, que especifica o tipo de objeto armazenado em ob, mas T é ilimitado e pode ser de qualquer tipo de classe.

• Para criar um método que aceite objetos Gen<tipo>, onde tipo é A ou uma subclasse de A, é necessário usar um curinga limitado.

• O método test() é um exemplo de como restringir o parâmetro de tipo usando um curinga limitado para aceitar apenas objetos Gen<A> ou suas subclasses.

// Aqui, o símbolo ? equivalerá a A ou a
// qualquer tipo de classe que estenda A.
static void test(Gen<? extends A> o) {
// ...
}

• A classe a seguir demonstra os tipos de objetos Gen que podem ser passados para test( ).

class UseBoundedWildcard {
// Aqui, o símbolo ? equivalerá a A ou a
// qualquer tipo de classe que estenda A.
static void test(Gen<? extends A> o) { // Usa um curinga limitado.
//...
}
public static void main(String args[]) {
A a = new A();
B b = new B();
C c = new C();
D d = new D();
Gen< A > w = new Gen< A >(a);
Gen< B > w2 = new Gen< B >(b);
Gen< C > w3 = new Gen< C >(c);
Gen< D > w4 = new Gen< D >(d);
//Essas chamadas são válidas porque w, w2 e w3 são subclasses de A.
test(w);
test(w2);
test(w3);
// Não pode chamar test() com w4 porque
// ele não é um objeto de uma classe que
// herde A.
//test(w4); // Error!
}
}

• No método main(), objetos dos tipos A, B, C e D são criados e usados para gerar objetos Gen para cada tipo.

• O método test() é chamado quatro vezes, mas a última chamada é comentada.

• As três primeiras chamadas são válidas, pois os objetos w, w2 e w3 têm tipos que são A ou subclasses de A.

• A última chamada é inválida porque o objeto w4 é do tipo D, que não é uma subclasse de A, e portanto não é aceito pelo curinga limitado de test().

• Para estabelecer o limite superior de um curinga, usamos <? extends superclasse>, onde superclasse é o tipo que define o limite.

• A cláusula extends é inclusiva, ou seja, a superclasse também faz parte do limite.

• Para definir um limite inferior, usamos <? super subclasse>, permitindo apenas classes que sejam superclasses da subclasse como argumentos.

• A cláusula super também é inclusiva.

Exemplo: WildcardSuper.java