6. De functionele interfaces van de bibliotheek RxJava

De klasse Observable vormt de basis van de asynchrone bibliotheek RxJava. Deze vertoont veel overeenkomsten met de klasse Stream die we zojuist hebben besproken. Net als die klasse beschikt deze over zeer veel methoden, tientallen zelfs. En net als die klasse accepteren deze methoden instanties van functionele interfaces als parameters. We beginnen met de meest gangbare daarvan: [Actioni] en [Funci].

6.1. Voorbeeld-01: de functionele interface [Action0]

De interface [Action0] ziet er als volgt uit:

De interface [Action0] heeft één enkele methode, `call`, met de handtekening [2]: `void call()`. Deze is afgeleid van de interfaces [Action] en [1, 3]. De interface [Action] heeft geen methoden. Dit soort interfaces worden markeerinterfaces genoemd, zoals [4]. Ze worden voornamelijk gebruikt om het volgende te schrijven: if(c instanceOf(Action)) {...}. De interface [Action] is zelf afgeleid van de markerinterface [Function] [4-6];

We zullen de interface [Action0] illustreren met de volgende code (Voorbeeld01):


package dvp.rxjava.lamdbas;

import rx.functions.Action0;

public class Exemple01 {
  public static void main(String[] args) {
    // Actie0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // weergaven
    a01.call();
    a02.call();
  }
}

regels 8-13: implementatie van de interface [Action0] met een anonieme klasse;
regels 8-13: implementatie van de interface [Action0] met een lambda;

De resultaten zijn als volgt:

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

6.2. Voorbeeld-02, 03: de functionele interface [Actioni]

De interface [Action1] ziet er als volgt uit:

We zullen dit illustreren met de volgende code (Voorbeeld 02):


package dvp.rxjava.lamdbas;

import rx.functions.Action1;

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

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

wat het volgende resultaat oplevert:

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

In het algemeen is [Actioni] (0<=i<=9) een functionele interface met als enige methode: void call(T1 t1, T2 t2, ..., Ti ti). Hier volgt een voorbeeld voor [Action2] (Voorbeeld03):


package dvp.rxjava.lamdbas;

import rx.functions.Action2;

public class Exemple03 {
  public static void main(String[] args) {
    // Actie2
    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);
    // uitvoeringen
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

Het verkregen resultaat is als volgt:

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

6.3. Voorbeeld-04, 05: de functionele interface [Funci]

De interface [Func0] ziet er als volgt uit:

Deze keer levert de methode [call] van de interface een resultaat van het type R op.

We zullen de interface illustreren met de volgende code:


package dvp.rxjava.lamdbas;

import rx.functions.Func0;

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

wat de volgende resultaten oplevert:

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

In het algemeen is [Funci] (0<=i<=9) een functionele interface met als enige methodesignatuur: R call(T1 t1, T2 t2, ..., Ti ti). Hier volgt een voorbeeld voor [Func2] (Voorbeeld05):


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

wat de volgende resultaten oplevert:

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