6. Le interfacce funzionali della libreria RxJava

La classe Observable costituisce la base della libreria asincrona RxJava. Presenta molte somiglianze con la classe Stream di cui abbiamo appena parlato. Come Stream, offre un gran numero di metodi — diverse dozzine. E come Stream, questi metodi accettano istanze di interfacce funzionali come parametri. Inizieremo introducendo quelle più comuni: [Action] e [Function].

6.1. Esempio-01: L'interfaccia funzionale [Action0]

L'interfaccia [Action0] è la seguente:

L'interfaccia [Action0] ha un unico metodo, `call`, con la firma [2]: `void call()`. Deriva dall'interfaccia [Action] [1, 3]. L'interfaccia [Action] non ha metodi. Questo tipo di interfaccia è chiamato interfaccia marcatrice [4]. Viene utilizzata principalmente per scrivere: if(c instanceOf(Action)) {...}. L'interfaccia [Action] stessa deriva dall'interfaccia marcatrice [Function] [4-6];

Illustreremo l'interfaccia [Action0] con il seguente codice (Esempio01):


package dvp.rxjava.lamdbas;
 
import rx.functions.Action0;
 
public class Exemple01 {
  public static void main(String[] args) {
    // Action0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // displays
    a01.call();
    a02.call();
  }
}

righe 8–13: implementazione dell'interfaccia [Action0] utilizzando una classe anonima;
righe 8–13: implementazione dell'interfaccia [Action0] utilizzando un lambda;

I risultati sono i seguenti:

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

6.2. Esempio-02, 03: l'interfaccia funzionale [Actioni]

L'interfaccia [Action1] è la seguente:

Lo illustreremo con il seguente codice (Esempio 02):


package dvp.rxjava.lamdbas;
 
import rx.functions.Action1;
 
public class Exemple02 {
  public static void main(String[] args) {
    // Action1
    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));
 
    // executions
    a10.call(20);
    a11.call(17.4);
  }
}

il che dà il seguente risultato:

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

In generale, [Actioni] (0 <= i <= 9) è un'interfaccia funzionale con un unico metodo della seguente firma: void call(T1 t1, T2 t2, ..., Ti ti). Ecco un esempio per [Action2] (Esempio03):


package dvp.rxjava.lamdbas;
 
import rx.functions.Action2;
 
public class Exemple03 {
  public static void main(String[] args) {
    // Action2
    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);
    // executions
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

Il risultato è il seguente:

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

6.3. Esempio-04, 05: l'interfaccia funzionale [Funci]

L'interfaccia [Func0] è la seguente:

In questo caso, il metodo [call] dell'interfaccia restituisce un risultato di tipo R.

Illustreremo l'interfaccia con il codice seguente:


package dvp.rxjava.lamdbas;

import rx.functions.Func0;
 
public class Exemple04 {
  public static void main(String[] args) {
    // Function0
    Func0<String> f00 = new Func0<String>() {
      @Override
      public String call() {
        return "anonymous f00.call";
      }
    };
    Func0<String> f01 = () -> "lambda f01.call";
    // executions
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

che produce i seguenti risultati:

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

In generale, [Funci] (0<=i<=9) è un'interfaccia funzionale con una singola firma di metodo: R call(T1 t1, T2 t2, ..., Ti ti). Ecco un esempio per [Func2] (Esempio05):


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);
    // displays
    System.out.println(f20.call(10,10.2));
    System.out.println(f21.call(100, 100.3));
  }
}

che restituisce i seguenti risultati:

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