6. Die funktionalen Schnittstellen der RxJava-Bibliothek

Die Klasse Observable bildet die Grundlage der asynchronen RxJava-Bibliothek. Sie weist viele Ähnlichkeiten mit der soeben besprochenen Stream-Klasse auf. Wie Stream bietet sie eine große Anzahl von Methoden – mehrere Dutzend. Und wie bei Stream akzeptieren diese Methoden Instanzen funktionaler Schnittstellen als Parameter. Wir beginnen mit der Vorstellung der gängigsten: [Action] und [Function].

6.1. Beispiel-01: Die funktionale Schnittstelle [Action0]

Die Schnittstelle [Action0] sieht wie folgt aus:

• Die Schnittstelle [Action0] verfügt über eine einzige Methode, `call`, mit der Signatur [2]: `void call()`. Sie leitet sich von der Schnittstelle [Action] ab [1, 3]. Die Schnittstelle [Action] hat keine Methoden. Diese Art von Schnittstelle wird als Marker-Schnittstelle bezeichnet [4]. Sie werden hauptsächlich verwendet, um Folgendes zu schreiben: if(c instanceOf(Action)) {...}. Die Schnittstelle [Action] selbst leitet sich von der Marker-Schnittstelle [Function] ab [4-6];

Wir werden die Schnittstelle [Action0] anhand des folgenden Codes veranschaulichen (Beispiel01):

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();
  }
}

• Zeilen 8–13: Implementierung der Schnittstelle [Action0] mithilfe einer anonymen Klasse;
• Zeilen 8–13: Implementierung der Schnittstelle [Action0] mithilfe eines Lambda-Ausdrucks;

Die Ergebnisse lauten wie folgt:

anonymous a01.call
lambda ao2.call

6.2. Beispiel-02, 03: die funktionale Schnittstelle [Actioni]

Die Schnittstelle [Action1] sieht wie folgt aus:

Wir veranschaulichen dies anhand des folgenden Codes (Beispiel 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);
  }
}

was folgendes Ergebnis liefert:

anonymous a10.call (20)
lambda a11.call (17.4)

Im Allgemeinen ist [Actioni] (0 <= i <= 9) eine funktionale Schnittstelle mit einer einzigen Methode der folgenden Signatur: void call(T1 t1, T2 t2, ..., Ti ti). Hier ist ein Beispiel für [Action2] (Beispiel03):

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);
  }
}

Das Ergebnis lautet wie folgt:

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

6.3. Beispiel 04, 05: die funktionale Schnittstelle [Funci]

Die Schnittstelle [Func0] sieht wie folgt aus:

In diesem Fall gibt die Methode [call] der Schnittstelle ein Ergebnis vom Typ R zurück.

Wir werden die Schnittstelle anhand des folgenden Codes veranschaulichen:

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());
  }
}

was zu folgenden Ergebnissen führt:

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

Im Allgemeinen ist [Funci] (0<=i<=9) eine funktionale Schnittstelle mit einer einzigen Methodensignatur: R call(T1 t1, T2 t2, ..., Ti ti). Hier ist ein Beispiel für [Func2] (Beispiel05):

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));
  }
}

was zu folgenden Ergebnissen führt:

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