3. Assinaturas de classes e métodos genéricos
 |
A biblioteca RxJava tem muitos métodos que aceitam instâncias de interfaces genéricas como parâmetros. Por vezes, as suas assinaturas são complexas. Aqui estão alguns exemplos:
public final <R> Observable<R> map(Func1<? super T,? extends R> func)
public final <R> Observable<R> flatMap(Func1<? super T,? extends Observable<? extends R>> func)
Estes dois métodos utilizam dois tipos genéricos, T e R. Mas o que significa a definição do parâmetro do método map, por exemplo: Func1<? super T,? extends R> func ?
Informações sobre genéricos podem ser encontradas no URL [https://docs.oracle.com/javase/tutorial/java/generics/]. Algumas das informações abaixo provêm deste URL. Os genéricos foram introduzidos na versão 1.5 do Java.
Imaginemos um serviço web que fornece informações de vários tipos. O serviço web pode, por vezes, não conseguir fornecer essas informações e, nesse caso, deve reportar um erro ao seu cliente. Podemos então padronizar a resposta do serviço web da seguinte forma:
public class Response<T> {
// ----------------- properties
// operation status
private int status;
// any error messages
private List<String> messages;
// the body of the reply
private T body;
...
}
- linha 1: a classe [Response] é parametrizada pelo tipo T;
- linha 9: o tipo T é o tipo do corpo da resposta, que é o que o cliente realmente espera;
- linha 5: um código de erro, 0 se não houver erro;
- linha 7: mensagens explicando o erro, nulo se não houver erro;
No lado do cliente, podemos então escrever:
Response<Product> product=getDataFromWebService(...) ;
ou
Response<List<Product>>=getDataFromWebService(...) ;
O tipo formal T é substituído por um tipo real, neste caso [Product] ou [List<Product>]. A classe genérica [Response<T>] é útil aqui porque nos permite trabalhar com uma resposta padrão.
Para criar um tipo [Response] utilizando o operador new, escrevemos:
Response<List<Product>> response=new Response<List<Product>> (...) ;
Desde a versão 1.8 do Java, a instrução anterior pode ser escrita de forma mais simples:
Response<List<Product>> response=new Response<> (...) ;
Já não é necessário especificar o tipo real dos parâmetros genéricos no lado direito do sinal de igual: em vez disso, será utilizado o tipo formal especificado no lado esquerdo do sinal de igual. Isto denomina-se inferência de tipos: o compilador é capaz de determinar por si próprio o tipo real dos parâmetros genéricos com base no contexto. Esta funcionalidade é amplamente utilizada em funções lambda, onde o tipo real dos parâmetros genéricos de um método é frequentemente omitido.
Agora, no lado do cliente, o método [getDataFromWebService] poderia ter a seguinte assinatura:
<T1,T2> Response<T1> getDataFromWebService(String urlWebService, String httpMethod, T2 post)
Aqui temos um método genérico parametrizado por dois tipos, T1 e T2:
- T1 é o tipo do corpo da resposta esperada;
- T2 é o tipo do valor enviado para uma operação POST, nulo para uma operação GET;
- urlWebService: é a URL do serviço web;
- httpMethod: é o método HTTP GET ou POST a utilizar ao consultar esta URL;
No lado do cliente, poderemos ter a seguinte chamada:
Long id=... ;
Response<Product> product=this.<Product,Long>getDataFromWebService('http://localhost:8080/rest/product','POST',id) ;
Neste caso, teremos T1=Product e T2=Long.
Com o Java 8, podemos usar a inferência de tipos e escrever de forma mais simples:
Long id=... ;
Response<Product> product=getDataFromWebService('http://localhost:8080/rest/product','POST',id) ;
Aqui está outra chamada possível:
Long[] ids=... ;
Response<List<Product>> product=getDataFromWebService('http://localhost:8080/rest/products','POST',ids) ;
Neste caso, teremos T1=List<Product> e T2=Long[].
A classe ou método genérico pode impor restrições aos seus parâmetros genéricos. Vamos rever a definição do método [map] no RxJava:
public final <R> Observable<R> map(Func1<? super T,? extends R> func)
O método aceita dois tipos de parâmetros, T e R. O tipo [Func1] é uma interface genérica:
 |
Func1 define uma interface funcional, ou seja, uma interface com um único método. As interfaces funcionais constituem a base das expressões lambda do Java 8. Aqui, o método da interface é definido como:
Assim, T é o tipo do parâmetro passado para [call] e R é o tipo do resultado obtido. Voltemos à definição do método [map]:
public final <R> Observable<R> map(Func1<? super T,? extends R> func)
- o método [map] espera um único parâmetro do tipo [Func1<? super T,? extends R>] e retorna um tipo [Observable<R>];
- ? super T: o parâmetro passado ao método [Func1.call] deve ser do tipo T ou de um supertipo de T;
- ? extends R: o tipo do resultado devolvido pelo método [call] deve ser do tipo R ou um subtipo, se R for uma classe, ou implementar R, se R for uma interface;
Para compreender melhor as duas restrições acima, vejamos alguns exemplos da referência [https://docs.oracle.com/javase/tutorial/java/generics/bounded.html]:
package tests;
public class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
public <U extends Number> void inspect(U u) {
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<>();
integerBox.set(new Integer(10));
integerBox.inspect(new Long(20));
integerBox.inspect(new Double(-1.78));
//integerBox.inspect("some text"); // error: this is still String!
}
}
- linha 3: a classe [Box] é parametrizada pelo tipo T, que é o tipo do campo na linha 5;
- linha 15: o método [inspect] recebe um parâmetro do tipo U. Um método também pode ter parâmetros genéricos. Nesse caso, é declarado da seguinte forma:
Aqui, U é declarado como o tipo genérico do método utilizando <U>, mas com uma restrição <U extends Number>, ou seja, U deve estender a classe [Number]. Devido a esta restrição, o compilador reporta um erro na linha 25;
- linhas 23–24: chamadas ao método [inspect] com tipos derivados de [Number];
São obtidos os seguintes resultados:
Nota: Para executar a classe no IntelliJ, siga estes passos [1, 2]:
 |
Agora, considere o seguinte exemplo:
public void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 3; i++) {
list.add(i);
}
}
O método [addNumbers] recebe uma Lista<T> como parâmetro, sendo que T é uma superclasse da classe [Integer]. Devido a esta restrição, os números inteiros de 1 a 3 podem ser adicionados à lista (linhas 2–4), e o método pode ser chamado da seguinte forma:
List<Number> numbers=new ArrayList<>();
// ajout double Number <-- Double
numbers.add(7.8);
// ajout Long Number <-- Long
numbers.add(1L);
// ajout List<Number> Number <-- Integer
addNumbers(numbers);
// affichagede List<Number>
for(Number number : numbers){
System.out.println(number.getClass().getName());
}
Isto produz o seguinte resultado:
Para estender a classe Box<T>, escreveríamos:
class OtherBox<T> extends Box<T> {
}
A classe filha pode, por sua vez, introduzir novos parâmetros genéricos:
class AnotherBox<T, T1> extends Box<T> {
void consumer(T1 t1) {
System.out.printf("%s%n", t1);
}
}
Uma interface também pode utilizar parâmetros genéricos:
interface I<T> {
void doSomethingWith(T t);
}
Para a implementar, utilize a seguinte sintaxe:
class A<T> implements I<T> {
@Override
public void doSomethingWith(T t) {
System.out.printf("%s%n", t);
}
}
Agora sabemos o suficiente sobre genéricos para lidar com funções lambda.