6. Le interfacce funzionali della libreria RxJava

La classe Observable costituisce la base della libreria asincrona RxJava. Presenta molte somiglianze con la classe Stream che abbiamo appena illustrato. Come quest’ultima, dispone di un numero molto elevato di metodi, diverse decine. E, proprio come quella, questi metodi accettano come parametri istanze di interfacce funzionali. Inizieremo presentando le più comuni tra queste: [Actioni] e [Funci].

6.1. Esempio-01: l’interfaccia funzionale [Action0]

L’interfaccia [Action0] è la seguente:

L'interfaccia [Action0] presenta un unico metodo, `call`, con la firma [2]: `void call()`. Deriva dalle interfacce [Action] e [1, 3]. L'interfaccia [Action] non ha metodi. Questo tipo di interfacce viene denominato «interfacce marcatori» [4]. Servono principalmente per scrivere: if(c instanceOf(Action)) {...}. L'interfaccia [Action] deriva a sua volta 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) {
    // Azione0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // visualizzazioni
    a01.call();
    a02.call();
  }
}

righe 8-13: implementazione dell'interfaccia [Action0] con una classe anonima;
righe 8-13: implementazione dell'interfaccia [Action0] con 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:

La illustreremo con il seguente codice (Esempio 02):


package dvp.rxjava.lamdbas;

import rx.functions.Action1;

public class Exemple02 {
  public static void main(String[] args) {
    // Azione1
    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));

    // esecuzioni
    a10.call(20);
    a11.call(17.4);
  }
}

che produce 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 di 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) {
    // Azione2
    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);
    // esecuzioni
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

Il risultato ottenuto è 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) {
    // Funzione0
    Func0<String> f00 = new Func0<String>() {
      @Override
      public String call() {
        return "anonymous f00.call";
      }
    };
    Func0<String> f01 = () -> "lambda f01.call";
    // esecuzioni
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

che fornisce 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 un unico metodo di firma: 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);
    // visualizzazioni
    System.out.println(f20.call(10,10.2));
    System.out.println(f21.call(100, 100.3));
  }
}

che fornisce i seguenti risultati:

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