6. As interfaces funcionais da biblioteca RxJava

A classe Observable constitui a base da biblioteca assíncrona RxJava. Apresenta muitas semelhanças com a classe Stream que acabámos de apresentar. Tal como esta, dispõe de um grande número de métodos, várias dezenas. E, tal como ela, esses métodos aceitam como parâmetros instâncias de interfaces funcionais. Vamos começar por apresentar as mais comuns: [Actioni] e [Funci].

6.1. Exemplo-01: a interface funcional [Action0]

A interface [Action0] é a seguinte:

A interface [Action0] possui um único método, «call», com a assinatura [2]: void call(). Deriva das interfaces [Action] e [1, 3]. A interface [Action] não possui métodos. Este tipo de interfaces é designado por interfaces marcadoras [4]. Servem principalmente para escrever: if(c instanceOf(Action)) {...}. A interface [Action] deriva, por sua vez, da interface marcadora [Function] [4-6];

Iremos ilustrar a interface [Action0] com o código seguinte (Exemplo01):


package dvp.rxjava.lamdbas;

import rx.functions.Action0;

public class Exemple01 {
  public static void main(String[] args) {
    // Ação 0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // visualizações
    a01.call();
    a02.call();
  }
}

linhas 8-13: implementação da interface [Action0] com uma classe anónima;
linhas 8-13: implementação da interface [Action0] com um lambda;

Os resultados são os seguintes:

1 2	`anonymous a01.call lambda ao2.call`

6.2. Exemplo-02, 03: a interface funcional [Actioni]

A interface [Action1] é a seguinte:

Iremos ilustrá-la com o código seguinte (Exemplo 02):


package dvp.rxjava.lamdbas;

import rx.functions.Action1;

public class Exemple02 {
  public static void main(String[] args) {
    // Ação1
    Action1<Integer> a10 = new Action1<Integer>() {
      @Override
      public void call(Integer integer) {
        System.out.printf("anonymous a10.call (%s)%n", integer);
      }
    };
    Action1<Double> a11 = (d -> System.out.printf("lambda a11.call (%s)%n", d));

    // execuções
    a10.call(20);
    a11.call(17.4);
  }
}

que produz o seguinte resultado:

1 2	`anonymous a10.call (20) lambda a11.call (17.4)`

De um modo geral, [Actioni] (0<=i<=9) é uma interface funcional com um único método de assinatura: void call(T1 t1, T2 t2, ..., Ti ti). Eis um exemplo para [Action2] (Exemplo03):


package dvp.rxjava.lamdbas;

import rx.functions.Action2;

public class Exemple03 {
  public static void main(String[] args) {
    // Ação 2
    Action2<Integer, Double> a20 = new Action2<Integer, Double>() {
      @Override
      public void call(Integer integer, Double aDouble) {
        System.out.printf("anonymous a20.call(%s,%s)%n", integer, aDouble);
      }
    };
    Action2<Integer, Double> a21 = (i, d) -> System.out.printf("lambda a21.call(%s,%s)%n", i, d);
    // execuções
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

O resultado obtido é o seguinte:

anonymous a20.call(10,11.3)
lambda a21.call(5,5.6)

6.3. Exemplo-04, 05: a interface funcional [Funci]

A interface [Func0] é a seguinte:

Desta vez, o método [call] da interface devolve um resultado do tipo R.

Iremos ilustrar a interface com o código seguinte:


package dvp.rxjava.lamdbas;

import rx.functions.Func0;

public class Exemple04 {
  public static void main(String[] args) {
    // Função0
    Func0<String> f00 = new Func0<String>() {
      @Override
      public String call() {
        return "anonymous f00.call";
      }
    };
    Func0<String> f01 = () -> "lambda f01.call";
    // execuções
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

que produz os seguintes resultados:

1 2	`anonymous a20.call(10,11.3) lambda a21.call(5,5.6)`

De um modo geral, [Funci] (0<=i<=9) é uma interface funcional com o único método de assinatura: R call(T1 t1, T2 t2, ..., Ti ti). Eis um exemplo para [Func2] (Exemplo05):


package dvp.rxjava.lamdbas;

import rx.functions.Func2;

public class Exemple05 {
  public static void main(String[] args) {
    // Func2
    Func2<Integer, Double, String> f20 = new Func2<Integer, Double, String>() {
      @Override
      public String call(Integer integer, Double aDouble) {
        return String.format("anonymous f20.call(%s,%s)", integer, aDouble);
      }
    };
    Func2<Integer, Double, String> f21 = (i,d) -> String.format("anonymous f21.call(%s,%s)", i, d);
    // visualizações
    System.out.println(f20.call(10,10.2));
    System.out.println(f21.call(100, 100.3));
  }
}

que produz os seguintes resultados:

1 2	`anonymous f20.call(10,10.2) anonymous f21.call(100,100.3)`