Usando argumentos curingas

• A segurança de tipos pode impedir certas construções válidas, como comparar valores absolutos de diferentes tipos numéricos.

• Um exemplo é o método absEqual(), que verifica se dois objetos NumericFns contêm números com valores absolutos iguais, mesmo que sejam de tipos diferentes, como Double e Float.

• O método compara o valor absoluto do objeto chamador com o do argumento passado.

NumericFns<Double> dOb = new NumericFns<Double>(1.25);
NumericFns<Float> fOb = new NumericFns<Float>(-1.25);
if(dOb.absEqual(fOb))
System.out.println("Absolute values are the same.");
else
System.out.println("Absolute values differ.");

• Criar o método absEqual() parece simples, mas surgem problemas ao definir o parâmetro de tipo para NumericFns.

• A dúvida está em qual tipo usar como parâmetro de NumericFns, já que ele deve lidar com diferentes tipos numéricos.

• Uma solução inicial seria usar o mesmo tipo genérico T, mas isso pode não atender a todos os casos.

Exemplo: Example1.java
// Este código não funcionará!
// Determina se os valores absolutos de dois objetos são iguais.
boolean absEqual(NumericFns<T> ob) {
if(Math.abs(num.doubleValue()) ==
Math.abs(ob.num.doubleValue()) return true;
return false;
}

• Usar Math.abs() para comparar valores absolutos em absEqual() só funciona se ambos os objetos NumericFns forem do mesmo tipo, como NumericFns<Integer>.

• Essa abordagem não é genérica e impede a comparação entre diferentes tipos, como NumericFns<Integer> e NumericFns<Double>.

• Para criar uma solução genérica, utiliza-se o argumento curinga (?), que representa um tipo desconhecido em Java.

// Determina se os valores absolutos de
// dois objetos são iguais.
boolean absEqual(NumericFns<?> ob) { // Observe o curinga.
if(Math.abs(num.doubleValue()) ==
Math.abs(ob.num.doubleValue())) return true;
return false;
}

• NumericFns<?> permite comparar dois objetos NumericFns de qualquer tipo, tornando o método genérico.

• Isso possibilita a comparação de valores absolutos entre objetos NumericFns com diferentes tipos numéricos.

// Usa um curinga.
class NumericFns<T extends Number> {
T num;
// Passa para o construtor uma referência
// a um objeto numérico.
NumericFns(T n) {
num = n;
}
// Retorna o recíproco.
double reciprocal() {
return 1 / num.doubleValue();
}
// Retorna o componente fracionário.
double fraction() {
return num.doubleValue() - num.intValue();
}
// Determina se os valores absolutos de
// dois objetos são iguais.
boolean absEqual(NumericFns<?> ob) {
if(Math.abs(num.doubleValue()) ==
Math.abs(ob.num.doubleValue())) return true;
return false;
}
// ...
}
// Demonstra um curinga.
class WildcardDemo {
public static void main(String args[]) {
NumericFns<Integer> iOb =
new NumericFns<Integer>(6);
NumericFns<Double> dOb =
new NumericFns<Double>(-6.0);
NumericFns<Long> lOb =
new NumericFns<Long>(5L);
System.out.println("Testing iOb and dOb.");
// Nesta chamada, o tipo curinga equivale a Double.
if(iOb.absEqual(dOb))
System.out.println("Absolute values are equal.");
else
System.out.println("Absolute values differ.");
System.out.println();
System.out.println("Testing iOb and lOb.");
// Nesta chamada, o curinga equivale a Long.
if(iOb.absEqual(lOb))
System.out.println("Absolute values are equal.");
else
System.out.println("Absolute values differ.");
}
}

• Observe estas duas chamadas a absEqual( ):
  if(iOb.absEqual(dOb))
if(iOb.absEqual(lOb))

• Com o curinga (<?>), é possível chamar absEqual() com objetos NumericFns de tipos diferentes, como NumericFns<Integer> e NumericFns<Double>, ou NumericFns<Long>.

• O curinga não altera os tipos permitidos para criar objetos NumericFns; isso continua sendo controlado pela cláusula extends na declaração.

• Ele apenas permite que qualquer objeto válido de NumericFns seja usado no método.