6. Les interfaces fonctionnelles de la bibliothèque RxJava

La classe Observable est à la base de la bibliothèque asynchrone RxJava. Elle présente beaucoup de similarités avec la classe Stream que nous venons de présenter. Comme elle, elle présente de très nombreuses méthodes, plusieurs dizaines. Et comme elle, ces méthodes admettent pour paramètres des instances d'interfaces fonctionnelles. Nous allons commencer par présenter les plus courantes de celles-ci : [Actioni] et [Funci].

6.1. Exemple-01 : l'interface fonctionnelle [Action0]

L'interface [Action0] est la suivante :

l'interface [Action0] a l'unique méthode call de signature [2] : void call(). Elle dérive de l'interface [Action] [1, 3]. L'interface [Action] n'a pas de méthodes. On appelle ce type d'interfaces, des interfaces marqueurs [4]. Elle servent principalement à écrire : if(c instanceOf(Action)) {...}. L'interface [Action] dérive elle-même de l'interface marqueur [Function] [4-6] ;

Nous illustrerons l'interface [Action0] avec le code suivant (Exemple01) :


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");
    // affichages
    a01.call();
    a02.call();
  }
}

lignes 8-13 : implémentation de l'interface [Action0] avec une classe anonyme ;
lignes 8-13 : implémentation de l'interface [Action0] avec un lambda ;

Les résultats sont les suivants :

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

6.2. Exemple-02, 03 : l'interface fonctionnelle [Actioni]

L'interface [Action1] est la suivante :

Nous l'illustrerons avec le code suivant (Exemple02) :


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

    // exécutions
    a10.call(20);
    a11.call(17.4);
  }
}

qui donne le résultat suivant :

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

De façon générale, [Actioni] (0<=i<=9) est une interface fonctionnelle ayant l'unique méthode de signature : void call(T1 t1, T2 t2, ..., Ti ti). Voici un exemple pour [Action2] (Exemple03) :


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);
    // exécutions
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

Le résultat obtenu est le suivant :

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

6.3. Exemple-04, 05 : l'interface fonctionnelle [Funci]

L'interface [Func0] est la suivante :

Cette fois-ci, la méthode [call] de l'interface rend un résultat de type R.

Nous l'illustrerons l'interface avec le code suivant :


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";
    // exécutions
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

qui donne les résultats suivants :

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

De façon générale, [Funci] (0<=i<=9) est une interface fonctionnelle ayant l'unique méthode de signature : R call(T1 t1, T2 t2, ..., Ti ti). Voici un exemple pour [Func2] (Exemple05) :


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

qui donne les résultats suivants :

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