Java Language
Interface Fluent

algorithm Android HTML javafx JavaScript MySQL Regular Expressions spring spring-boot SQL
Recherche…


Remarques

Buts

L'objectif principal d'une interface Fluent est d'améliorer la lisibilité.

Lorsqu'il est utilisé pour construire des objets, les choix disponibles pour l'appelant peuvent être clairement définis et appliqués via des contrôles à la compilation. Par exemple, considérez l’arbre suivant des options représentant des étapes le long du chemin pour construire un objet complexe: 

A -> B 
  -> C -> D -> Done
       -> E -> Done
       -> F -> Done.
       -> G -> H -> I -> Done.

Un constructeur utilisant une interface fluide permettrait à l'appelant de voir facilement quelles options sont disponibles à chaque étape. Par exemple, A -> B est possible, mais A -> C n'est pas et entraînerait une erreur de compilation.

Vérité - Cadre de test courant

De "Comment utiliser la vérité" http://google.github.io/truth/ 

String string = "awesome";
assertThat(string).startsWith("awe");
assertWithMessage("Without me, it's just aweso").that(string).contains("me");

Iterable<Color> googleColors = googleLogo.getColors();
assertThat(googleColors)
    .containsExactly(BLUE, RED, YELLOW, BLUE, GREEN, RED)
    .inOrder();

Style de programmation fluide

Dans un style de programmation courant, vous retournez this partir de méthodes courantes (setter) qui ne renverraient rien dans un style de programmation non fluide.

Cela vous permet d'enchaîner les différents appels de méthode, ce qui rend votre code plus court et plus facile à gérer pour les développeurs.

Considérez ce code non fluide: 

public class Person {
  private  String firstName;
  private String lastName;

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String whoAreYou() {
    return "I am " + firstName + " " + lastName;
  }

  public static void main(String[] args) {
    Person person = new Person();
    person.setFirstName("John");
    person.setLastName("Doe");
    System.out.println(person.whoAreYou());
  }
}

Comme les méthodes setter ne renvoient rien, nous avons besoin de 4 instructions dans la méthode main pour instancier une Person avec certaines données et l'imprimer. Avec un style courant, ce code peut être modifié pour: 

public class Person {
  private  String firstName;
  private String lastName;

  public String getFirstName() {
    return firstName;
  }

  public Person withFirstName(String firstName) {
    this.firstName = firstName;
    return this;
  }

  public String getLastName() {
    return lastName;
  }

  public Person withLastName(String lastName) {
    this.lastName = lastName;
    return this;
  }

  public String whoAreYou() {
    return "I am " + firstName + " " + lastName;
  }

  public static void main(String[] args) {
    System.out.println(new Person().withFirstName("John")
      .withLastName("Doe").whoAreYou());
  }
}

L'idée est de toujours renvoyer un objet pour permettre la construction d'une chaîne d'appels de méthode et pour utiliser des noms de méthodes qui reflètent une expression naturelle. Ce style courant rend le code plus lisible.



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow